add testcase for java-sdk. (#346)

Signed-off-by: yongpengli-z <yongpeng.li@zilliz.com>

tests/milvustest/.gitignore

@@ -0,0 +1,33 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+*/.DS_Store
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/

tests/milvustest/README.md

@@ -0,0 +1,174 @@
+<p align="center">
+    <a href="https://milvus.io/">
+       <img src="https://zilliz.com/images/mask.png" style="height: 250px">
+    </a>
+</p>
+
+# 测试框架使用说明
+
+## 简介
+
+基于TestNG编写的的针对**milvus-sdk-java**测试的的自动化测试框架。
+
+## 快速开始
+
+### 环境准备
+
+-[安装java-sdk](https://www.oracle.com/java/technologies/downloads/)
+
+-[安装maven](http://maven.apache.org/download.cgi)
+
+### 启动 Milvus
+
+- [安装 Milvus 单机版](https://milvus.io/cn/docs/v2.0.0/install_standalone-docker.md)
+
+- [安装 Milvus 分布式版本](https://milvus.io/cn/docs/v2.0.0/install_cluster-docker.md)
+
+### 引入MILVUS-SKD-JAVA
+
+#### 仓库（maven）
+
+![img.png](src/main/resources/images/img.png)
+
+#### 中央仓库
+
+```xml
+
+<dependency>
+    <groupId>io.milvus</groupId>
+    <artifactId>milvus-sdk-java</artifactId>
+    <version>2.0.4</version>
+</dependency>
+```
+
+#### 私库
+
+- 仓库地址：http://10.13.0.84:9081/#browse/browse:nexus-snapshots:io
+
+- 参考开发环境：https://zilliverse.feishu.cn/wiki/wikcnjtrUdSxgjcG3nLXe8C7bKf#
+
+- 打开Maven安装目录下\conf文件，编辑settings.xml，在<services>标签下添加
+
+```xml
+
+<servers>
+    <server>
+        <id>nexus-releases</id>  <!--对应pom.xml的id=releases的仓库-->
+        <username>admin</username>
+        <password>admin123</password>
+    </server>
+    <server>
+        <id>nexus-snapshots</id> <!--对应pom.xml中id=snapshots的仓库-->
+        <username>admin</username>
+        <password>admin123</password>
+    </server>
+</servers>
+```
+
+- 在pom文件中加入distributionManagement节点
+
+```xml
+
+<distributionManagement>
+    <!--正式版本-->
+    <repository>
+        <!-- nexus服务器中用户名：在settings.xml中<server>的id-->
+        <id>nexus-snapshots</id>
+        <name>Snapshots repository</name>
+        <url>http://10.13.0.84:9081/repository/nexus-snapshot/</url>
+    </repository>
+    <snapshotRepository>
+        <id>nexus-snapshots</id>
+        <name>Snapshots repository</name>
+        <url>http://10.13.0.84:9081/repository/nexus-snapshot/</url>
+    </snapshotRepository>
+</distributionManagement>
+```
+
+- 修改milvus-sdk-java坐标version
+
+```xml
+
+<dependency>
+    <groupId>io.milvus</groupId>
+    <artifactId>milvus-sdk-java</artifactId>
+    <version>2.0.5-SNAPSHOT</version>
+</dependency>
+```
+
+## 模块介绍
+
+### 文件结构
+
+```ignorelang
+.
+├── allure-result  allure报告收集的运行结果集
+├── log  日志目录
+├── src
+    ├──java    
+        ├── aop  切面编程目录
+        ├── common  项目静态资源
+            ├── BaseTest  封装的基础测试类   
+            └── Common*  封装的测试方法和数据
+        ├── entity  实体类
+        ├── service  项目服务类
+        ├── util  工具类
+    ├── resources  资源配置文件
+    └── test  测试类集
+├── pom.xml 项目依赖
+└──testng.xml  testng配置文件
+```
+
+### 设计思路
+
+- BaseTest类，继承AbstractTestNGSpringContextTests类，为每个测试类提供MilvusServiceClient，方便调用。通过@BeforeSuite提供默认的Collection、Index、Partition
+等供测试类使用。
+
+- test文件里，每一个测试类对应一个接口，每个类之间相互解耦，非必要，不依赖。同类型接口放到同一个文件夹下。接口类的串行测试放到单独文件。
+
+- CommonData,CommonFunction提供公用的参数和方法。
+  
+- tesgng.xml文件，提供测试运行配置和测试数据的参数化。
+
+- allure-results文件夹，负责测试运行数据的收集和测试报告的创建。
+
+### testNG介绍
+常用注解：
+
+| **注解**       | **描述** |
+| ------------- | ------------------------------------------------------|
+| @Test         | 标记一个类里所有的public void方法，或某个方法，作为测试案例。|
+| @BeforeSuite  | 对于套件测试，在此套件中的所有测试执行之前运行，仅运行一次。|
+| @AfterSuite   |对于套件测试，在此套件中的所有测试执行之后运行，仅运行一次。|
+| @BeforeClass   |在调用当前类之前运行，只运行一次。|
+| @AfterClass	|在调用当前类之后运行，只运行一次。|
+| @BeforeTest	|对于套件测试，在属于标签内的所有类的测试方法执行之前运行。|
+| @AfterTest	|对于套件测试，在属于标签内的所有类的测试方法都已执行完之后运行。|
+| @BeforeGroups	|在调用属于该组的第一个测试方法之前运行。|
+| @AfterGroups	|在调用属于该组的最后一个测试方法执行之后运行 。|
+| @BeforeMethod	|注解的方法将每个测试方法之前运行。|
+| @AfterMethod	|在每个测试方法执行之前都会运行。|
+| @DataProvider	|标志着一个方法，提供数据的一个测试方法。注解的方法必须返回一个Object[] []，其中每个对象[]的测试方法的参数列表中可以分配。该@Test 方法，希望从这个DataProvider的接收数据，需要使用一个dataProvider名称等于这个注解的名字。|
+| @Factory	    |作为一个工厂，返回TestNG的测试类的对象将被用于标记的方法。该方法必须返回Object[]。|
+| @Listeners	|定义一个测试类的监听器。|
+| @Parameters	|用于将参数传递给@Test方法。|
+
+
+## 代码添加
+
+### 注意事項
+
+- 每个测试接口对应一个测试类，新增用例时，先检查是否已有对应的类。
+- 新建、删除类的的接口，使用CommonFunction里创建新的操作对象；查询、修改类接口可以直接使用BaseTest里创建的操作对象。
+- 一般情况下，不在测试用例文件中直接添加日志代码。
+- 测试用例里无需单独初始化MilvusClient。
+
+
+## 后续工作
+
+- 日志功能的完善
+- 测试数据的分离实现
+
+
+
+

tests/milvustest/allure-results/environment.properties

@@ -0,0 +1,3 @@
+milvus.url=10.98.0.8
+milvus.version=2.1.0
+milvus-jdk-java.version=2.1.0

tests/milvustest/pom.xml

@@ -0,0 +1,163 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.6.7</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
+    <groupId>com.zilliz</groupId>
+    <artifactId>milvustest</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>milvustest</name>
+    <description>Auto Tests for milvus-sdk-java</description>
+    <properties>
+        <java.version>1.8</java.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <!--TestNg Aullre Report使用-->
+        <aspectj.version>1.9.2</aspectj.version> <!--AspectJ是一个基于Java语言的AOP框架-->
+        <allure.version>2.13.2</allure.version>
+        <xmlFileName>testng.xml</xmlFileName>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.testng/testng -->
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>7.4.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-test</artifactId>
+        </dependency>
+        <!-- Jackson序列化和反序列化 -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+            <version>2.10.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.10.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>2.10.1</version>
+        </dependency>
+        <dependency>
+            <groupId>io.milvus</groupId>
+            <artifactId>milvus-sdk-java</artifactId>
+            <version>2.1.0-beta3</version>
+        </dependency>
+        <!--Allure报告依赖包-->
+        <dependency>
+            <groupId>io.qameta.allure</groupId>
+            <artifactId>allure-testng</artifactId>
+            <version>${allure.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <!--Allure报告生成插件依赖包-->
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+            <version>${aspectj.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
+        <dependency>
+            <groupId>io.minio</groupId>
+            <artifactId>minio</artifactId>
+            <version>8.4.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>okhttp</artifactId>
+            <version>4.9.0</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>${project.name}</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>2.6.7</version>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.22.1</version>
+                <configuration>
+                    <argLine>
+                        -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
+                    </argLine>
+                    <!--生成allure-result的目录-->
+                    <systemProperties>
+                        <!--是否忽略html，解释见下图。与之后在reportNg报告上显示截图相关。当前已经使用allure了，这里可以直接去掉啦-->
+                        <!--<org.uncommons.reportng.escape-output>false</org.uncommons.reportng.escape-output>-->
+                        <!--定义输出在项目 target 目录-->
+                        <property>
+                            <name>allure.results.directory</name>
+                            <value>./target/allure-results</value>
+                        </property>
+                    </systemProperties>
+                    <!--测试失败后，是否忽略并继续测试-->
+                    <testFailureIgnore>true</testFailureIgnore>
+                    <argLine>
+                        -Dfile.encoding=UTF-8
+                    </argLine>
+                    <suiteXmlFiles>
+                        <!--该文件位于工程根目录时，直接填写名字，其它位置要加上路径-->
+                        <suiteXmlFile>${xmlFileName}</suiteXmlFile>
+                    </suiteXmlFiles>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+
+
+</project>

tests/milvustest/src/main/java/com/zilliz/milvustest/MilvustestApplication.java

@@ -0,0 +1,12 @@
+package com.zilliz.milvustest;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class MilvustestApplication {
+
+  public static void main(String[] args) {
+    SpringApplication.run(MilvustestApplication.class, args);
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/common/BaseTest.java

@@ -0,0 +1,424 @@
+package com.zilliz.milvustest.common;
+
+import com.zilliz.milvustest.MilvustestApplication;
+import com.zilliz.milvustest.util.MathUtil;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.*;
+import io.milvus.param.alias.CreateAliasParam;
+import io.milvus.param.collection.CreateCollectionParam;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.FieldType;
+import io.milvus.param.collection.HasCollectionParam;
+import io.milvus.param.credential.CreateCredentialParam;
+import io.milvus.param.credential.DeleteCredentialParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import org.apache.log4j.Logger;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.testng.annotations.AfterSuite;
+import org.testng.annotations.BeforeSuite;
+import org.testng.asserts.SoftAssert;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+@SpringBootTest(classes = MilvustestApplication.class)
+@WebAppConfiguration
+public class BaseTest extends AbstractTestNGSpringContextTests {
+  public static Logger logger = Logger.getLogger(BaseTest.class);
+  public static SoftAssert softAssert = new SoftAssert();
+  public static final MilvusServiceClient milvusClient =
+      new MilvusServiceClient(
+          ConnectParam.newBuilder()
+              .withHost(
+                  System.getProperty("milvusHost") == null
+                      ? PropertyFilesUtil.getRunValue("milvusHost")
+                      : System.getProperty("milvusHost"))
+              .withPort(
+                  Integer.parseInt(
+                      System.getProperty("milvusPort") == null
+                          ? PropertyFilesUtil.getRunValue("milvusPort")
+                          : System.getProperty("milvusPort")))
+             //.withAuthorization("root","1qaz@WSX")
+             //.withAuthorization("root","Milvus")
+              //.withAuthorization("root", "Lyp0107!")
+             //.withAuthorization(CommonData.defaultUserName,CommonData.defaultPassword)
+              //.withSecure(true)
+              .build());
+
+  @BeforeSuite
+  public void initCollection() {
+    System.out.println(
+        "**************************************************BeforeSuit**********************");
+    initEvn();
+    // check collection is existed
+    List<String> collections =
+        new ArrayList<String>() {
+          {
+            add(CommonData.defaultCollection);
+            add(CommonData.defaultBinaryCollection);
+            add(CommonData.defaultStringPKCollection);
+            add(CommonData.defaultStringPKBinaryCollection);
+          }
+        };
+    checkCollection(collections);
+    // create collection with  float Vector
+    initFloatVectorCollection();
+    // create collection with binary vector
+    initBinaryVectorCollection();
+    // create String PK collection with  float Vector
+    initStringPKCollection();
+    // create String PK collection with  binary Vector
+    initStringPKBinaryCollection();
+
+  }
+
+  @AfterSuite
+  public void cleanTestData() {
+    System.out.println(
+        "**************************************************AfterSuit**********************");
+    logger.info("drop Default Collection");
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .build());
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .build());
+    logger.info("delete Default Credential:" + CommonData.defaultUserName);
+    milvusClient.deleteCredential(
+        DeleteCredentialParam.newBuilder().withUsername(CommonData.defaultUserName).build());
+    milvusClient.close();
+  }
+
+  public void initEvn() {
+    logger.info("Initializing the Environment");
+    // delete allure-result
+    logger.info("Deletes all history json in the  allure-result folder");
+    MathUtil.delAllFile("allure-results");
+    // write environment for allure
+    String filename = "./allure-results/environment.properties";
+    Path path = Paths.get(filename);
+    String contentStr =
+        "milvus.url="
+            + PropertyFilesUtil.getRunValue("milvusHost")
+            + "\n"
+            + "milvus.version="
+            + PropertyFilesUtil.getRunValue("milvusV")
+            + "\n"
+            + "milvus-jdk-java.version="
+            + PropertyFilesUtil.getRunValue("milvusJdkJavaV")
+            + "";
+    try (BufferedWriter writer = Files.newBufferedWriter(path, StandardCharsets.UTF_8)) {
+      writer.write(contentStr);
+    } catch (IOException e) {
+      logger.error(e.getMessage());
+    }
+  }
+
+  // generate collection with binary vector
+  public void initBinaryVectorCollection() {
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultBinaryVectorField)
+            .withDataType(DataType.BinaryVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withDescription("Test " + CommonData.defaultBinaryCollection + " search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    logger.info("Create binary vector collection:" + CommonData.defaultBinaryCollection);
+    milvusClient.createCollection(createCollectionReq);
+    logger.info(
+        CommonData.defaultBinaryCollection
+            + "Create Partition:"
+            + CommonData.defaultBinaryPartition);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionName(CommonData.defaultBinaryPartition)
+            .build());
+    logger.info(
+        (CommonData.defaultBinaryCollection + "Create Alies:" + CommonData.defaultBinaryAlias));
+    milvusClient.createAlias(
+        CreateAliasParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withAlias(CommonData.defaultBinaryAlias)
+            .build());
+    logger.info(
+        CommonData.defaultBinaryCollection + "Create Index:" + CommonData.defaultBinaryIndex);
+    milvusClient.createIndex(
+        CreateIndexParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withFieldName(CommonData.defaultBinaryVectorField)
+            .withIndexName(CommonData.defaultBinaryIndex)
+            .withMetricType(MetricType.JACCARD)
+            .withIndexType(IndexType.BIN_IVF_FLAT)
+            .withExtraParam(CommonData.defaultExtraParam)
+            .withSyncMode(Boolean.FALSE)
+            .build());
+    logger.info("insert data");
+
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionName(CommonData.defaultBinaryPartition)
+            .withFields(CommonFunction.generateBinaryData(2000))
+            .build());
+  }
+
+  // generate collection with float vector
+  public void initFloatVectorCollection() {
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withDescription("Test " + CommonData.defaultCollection + " search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    logger.info("Create Default Collection:" + CommonData.defaultCollection);
+    milvusClient.createCollection(createCollectionReq);
+
+    logger.info((CommonData.defaultCollection + "Create Alies:" + CommonData.defaultAlias));
+    milvusClient.createAlias(
+        CreateAliasParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withAlias(CommonData.defaultAlias)
+            .build());
+
+    logger.info(CommonData.defaultCollection + "Create Partition:" + CommonData.defaultPartition);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(CommonData.defaultPartition)
+            .build());
+
+    logger.info(CommonData.defaultCollection + "Create Index:" + CommonData.defaultIndex);
+    milvusClient.createIndex(
+        CreateIndexParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withFieldName(CommonData.defaultVectorField)
+            .withIndexName(CommonData.defaultIndex)
+            .withMetricType(MetricType.L2)
+            .withIndexType(IndexType.IVF_FLAT)
+            .withExtraParam(CommonData.defaultExtraParam)
+            .withSyncMode(Boolean.FALSE)
+            .build());
+
+    logger.info("insert data");
+    List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(CommonData.defaultPartition)
+            .withFields(fields)
+            .build());
+    logger.info("Create Default Credential:" + CommonData.defaultUserName);
+    milvusClient.createCredential(
+        CreateCredentialParam.newBuilder()
+            .withUsername(CommonData.defaultUserName)
+            .withPassword(CommonData.defaultPassword)
+            .build());
+  }
+
+  // generate Collection with String primary key and float vector
+  public void initStringPKCollection() {
+    FieldType strFieldType1 =
+        FieldType.newBuilder()
+            .withName("book_name")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(20)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType strFieldType2 =
+        FieldType.newBuilder()
+            .withName("book_content")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(20)
+            .build();
+    FieldType strFieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createStrCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withDescription("Test" + CommonData.defaultStringPKCollection + "search")
+            .withShardsNum(2)
+            .addFieldType(strFieldType1)
+            .addFieldType(strFieldType2)
+            .addFieldType(strFieldType3)
+            .build();
+    BaseTest.milvusClient.createCollection(createStrCollectionReq);
+    logger.info(
+        "Create default String pk collection with String type field:" + CommonData.defaultStringPKCollection);
+
+    logger.info((CommonData.defaultStringPKCollection + "Create Alies:" + CommonData.defaultStringPKAlias));
+    milvusClient.createAlias(
+            CreateAliasParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withAlias(CommonData.defaultStringPKAlias)
+                    .build());
+
+    logger.info(CommonData.defaultStringPKCollection + "Create Partition:" + CommonData.defaultStringPKPartition);
+    milvusClient.createPartition(
+            CreatePartitionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionName(CommonData.defaultStringPKPartition)
+                    .build());
+
+    logger.info(CommonData.defaultStringPKCollection + "Create Index:" + CommonData.defaultIndex);
+    milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withFieldName(CommonData.defaultVectorField)
+                    .withIndexName(CommonData.defaultIndex)
+                    .withMetricType(MetricType.L2)
+                    .withIndexType(IndexType.IVF_FLAT)
+                    .withExtraParam(CommonData.defaultExtraParam)
+                    .withSyncMode(Boolean.FALSE)
+                    .build());
+
+    logger.info("insert data");
+    List<InsertParam.Field> fields = CommonFunction.generateStringData();
+    milvusClient.insert(
+            InsertParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionName(CommonData.defaultStringPKPartition)
+                    .withFields(fields)
+                    .build());
+
+  }
+
+  // generate Collection with String primary key and binary vector
+  public void initStringPKBinaryCollection() {
+    FieldType strFieldType1 =
+            FieldType.newBuilder()
+                    .withName("book_name")
+                    .withDataType(DataType.VarChar)
+                    .withMaxLength(20)
+                    .withPrimaryKey(true)
+                    .withAutoID(false)
+                    .build();
+    FieldType strFieldType2 =
+            FieldType.newBuilder()
+                    .withName("book_content")
+                    .withDataType(DataType.VarChar)
+                    .withMaxLength(20)
+                    .build();
+    FieldType strFieldType3 =
+            FieldType.newBuilder()
+                    .withName(CommonData.defaultBinaryVectorField)
+                    .withDataType(DataType.BinaryVector)
+                    .withDimension(128)
+                    .build();
+    CreateCollectionParam createStrCollectionReq =
+            CreateCollectionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .withDescription("Test" + CommonData.defaultStringPKBinaryCollection + "search")
+                    .withShardsNum(2)
+                    .addFieldType(strFieldType1)
+                    .addFieldType(strFieldType2)
+                    .addFieldType(strFieldType3)
+                    .build();
+    BaseTest.milvusClient.createCollection(createStrCollectionReq);
+    logger.info(
+            "Create default String pk and  binary vector collection with String type field:" + CommonData.defaultStringPKBinaryCollection);
+
+    logger.info(CommonData.defaultStringPKBinaryCollection + "Create Partition:" + CommonData.defaultStringPKBinaryPartition);
+    milvusClient.createPartition(
+            CreatePartitionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .withPartitionName(CommonData.defaultStringPKBinaryPartition)
+                    .build());
+
+    logger.info(CommonData.defaultStringPKBinaryCollection + "Create Index:" + CommonData.defaultBinaryIndex);
+    milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .withFieldName(CommonData.defaultBinaryVectorField)
+                    .withIndexName(CommonData.defaultBinaryIndex)
+                    .withMetricType(MetricType.JACCARD)
+                    .withIndexType(IndexType.BIN_IVF_FLAT)
+                    .withExtraParam(CommonData.defaultExtraParam)
+                    .withSyncMode(Boolean.FALSE)
+                    .build());
+
+    logger.info("insert data");
+    List<InsertParam.Field> fields = CommonFunction.generateStringPKBinaryData(2000);
+    R<MutationResult> insert = milvusClient.insert(
+            InsertParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .withPartitionName(CommonData.defaultStringPKBinaryPartition)
+                    .withFields(fields)
+                    .build());
+    logger.info("String pk and binary vector collection insert data"+insert.getStatus());
+
+  }
+  public void checkCollection(List<String> collections) {
+    collections.forEach(
+        x -> {
+          R<Boolean> booleanR =
+              milvusClient.hasCollection(
+                  HasCollectionParam.newBuilder().withCollectionName(x).build());
+          if (booleanR.getData()) {
+            milvusClient.dropCollection(
+                DropCollectionParam.newBuilder().withCollectionName(x).build());
+          }
+        });
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonData.java

@@ -0,0 +1,30 @@
+package com.zilliz.milvustest.common;
+
+public class CommonData {
+  public static String defaultCollection = "CollectionAutoTest";
+  public static String defaultBinaryCollection = "BinaryCollectionAutoTest";
+  public static String defaultStringPKCollection = "CollectionStringPKAutoTest";
+  public static String defaultStringPKBinaryCollection = "BinaryCollectionStringPKAutoTest";
+  public static String defaultPartition = "PartitionAutoTest";
+  public static String defaultBinaryPartition = "BinaryPartitionAutoTest";
+  public static String defaultStringPKPartition = "PartitionStringPKAutoTest";
+  public static String defaultStringPKBinaryPartition = "BinaryPartitionStringPKAutoTest";
+  public static String defaultAlias = "AliasAutoTest";
+  public static String defaultStringPKAlias = "StringPKAliasAutoTest";
+  public static String defaultBinaryAlias = "BinaryAliasAutoTest";
+  public static String defaultStringPKBinaryAlias = "StringPKBinaryAliasAutoTest";
+  public static String defaultVectorField = "VectorFieldAutoTest";
+  public static String defaultBinaryVectorField = "BinaryVectorFieldAutoTest";
+  public static String defaultIndex = "FloatVectorIndex";
+
+  public static String defaultBinaryIndex = "BinaryVectorIndex";
+  public static String defaultExtraParam =
+      "{\"nlist\":1024,\"M\":16,\"efConstruction\":64, \"PQM\":16,\"nbits\":8}";
+  public static String defaultUserName = "UserNameAT";
+  public static String defaultPassword = "Password123AT";
+  public static String defaultBulkLoadPath = "./src/test/java/resources/temp/";
+  public static String defaultRowJson = "rowJson";
+  public static String defaultRowStrJson = "rowStrJson";
+  public static String defaultColJson = "colJson";
+  public static String defaultColStrJson = "colStrJson";
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/common/CommonFunction.java

@@ -0,0 +1,387 @@
+package com.zilliz.milvustest.common;
+
+import com.zilliz.milvustest.entity.FileBody;
+import com.zilliz.milvustest.entity.MilvusEntity;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.DataType;
+import io.milvus.param.IndexType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.alias.CreateAliasParam;
+import io.milvus.param.collection.CreateCollectionParam;
+import io.milvus.param.collection.FieldType;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import org.apache.log4j.Logger;
+import org.springframework.stereotype.Component;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+@Component
+public class CommonFunction {
+  static Logger logger = Logger.getLogger(CommonFunction.class);
+
+  // int PK, float vector collection
+  public static String createNewCollection() {
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test" + collectionName + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = BaseTest.milvusClient.createCollection(createCollectionReq);
+    logger.info("create collection:" + collectionName);
+    return collectionName;
+  }
+
+  // int PK,  binary vector collection
+  public static String createBinaryCollection() {
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultBinaryVectorField)
+            .withDataType(DataType.BinaryVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test" + collectionName + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = BaseTest.milvusClient.createCollection(createCollectionReq);
+    logger.info("create collection:" + collectionName);
+    return collectionName;
+  }
+
+  // String pk,float vector collection
+  public static String createStringPKCollection() {
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_name")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(20)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder()
+            .withName("book_content")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(20)
+            .build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultVectorField)
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test" + collectionName + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = BaseTest.milvusClient.createCollection(createCollectionReq);
+    logger.info("生成collection:" + collectionName);
+    return collectionName;
+  }
+
+  // String PK, binary vector collection
+  public static String createStringPKAndBinaryCollection() {
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_name")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(20)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder()
+            .withName("book_content")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(20)
+            .build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName(CommonData.defaultBinaryVectorField)
+            .withDataType(DataType.BinaryVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test" + collectionName + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = BaseTest.milvusClient.createCollection(createCollectionReq);
+    logger.info("Create String pk and binary vector collection:" + collectionName);
+    return collectionName;
+  }
+
+  public static MilvusEntity createCollectionWithAll() {
+    MilvusEntity milvusEntity = new MilvusEntity();
+    milvusEntity.setCollection("Collection_" + MathUtil.getRandomString(10));
+    milvusEntity.setAlias("alias_" + MathUtil.getRandomString(5));
+    milvusEntity.setPartition("partition_" + MathUtil.getRandomString(10));
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.FloatVector)
+            .withDimension(2)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(milvusEntity.getCollection())
+            .withDescription("Test" + milvusEntity.getCollection() + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    BaseTest.milvusClient.createCollection(createCollectionReq);
+    BaseTest.milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(milvusEntity.getCollection())
+            .withPartitionName(milvusEntity.getPartition())
+            .build());
+    BaseTest.milvusClient.createAlias(
+        CreateAliasParam.newBuilder()
+            .withCollectionName(milvusEntity.getCollection())
+            .withAlias(milvusEntity.getAlias())
+            .build());
+
+    return milvusEntity;
+  }
+
+  public static List<InsertParam.Field> generateData(int num) {
+    Random ran = new Random();
+    List<Long> book_id_array = new ArrayList<>();
+    List<Long> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < num; ++i) {
+      book_id_array.add(i);
+      word_count_array.add(i + 10000);
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 128; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    // logger.info("generateTestData"+ JacksonUtil.serialize(fields));
+    return fields;
+  }
+
+  public static void insertDataIntoCollection(String collection, List<InsertParam.Field> fields) {
+    BaseTest.milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(collection).withFields(fields).build());
+  }
+
+  public static List<FileBody> generateDefaultFileBody() {
+    List<FileBody> fileBodyList = new ArrayList<>();
+    FileBody bookid = new FileBody();
+    bookid.setFieldName("book_id");
+    bookid.setFieldType(com.zilliz.milvustest.entity.FieldType.PK_FIELD);
+    FileBody words = new FileBody();
+    words.setFieldName("word_count");
+    words.setFieldType(com.zilliz.milvustest.entity.FieldType.INT_FIELD);
+    FileBody vectorField = new FileBody();
+    vectorField.setFieldName(CommonData.defaultVectorField);
+    vectorField.setFieldType(com.zilliz.milvustest.entity.FieldType.FLOAT_VECTOR_FIELD);
+    fileBodyList.add(bookid);
+    fileBodyList.add(words);
+    fileBodyList.add(vectorField);
+    return fileBodyList;
+  }
+
+  public static List<FileBody> generateDefaultStringFileBody() {
+    List<FileBody> fileBodyList = new ArrayList<>();
+    FileBody bookid = new FileBody();
+    bookid.setFieldName("book_name");
+    bookid.setFieldType(com.zilliz.milvustest.entity.FieldType.STRING_PK_FIELD);
+    FileBody words = new FileBody();
+    words.setFieldName("book_content");
+    words.setFieldType(com.zilliz.milvustest.entity.FieldType.STRING_FIELD);
+    FileBody vectorField = new FileBody();
+    vectorField.setFieldName(CommonData.defaultVectorField);
+    vectorField.setFieldType(com.zilliz.milvustest.entity.FieldType.FLOAT_VECTOR_FIELD);
+    fileBodyList.add(bookid);
+    fileBodyList.add(words);
+    fileBodyList.add(vectorField);
+    return fileBodyList;
+  }
+
+  public static List<InsertParam.Field> generateBinaryData(int num) {
+    Random ran = new Random();
+    List<Long> book_id_array = new ArrayList<>();
+    List<Long> word_count_array = new ArrayList<>();
+    for (long i = 0L; i < num; ++i) {
+      book_id_array.add(i);
+      word_count_array.add(i + 10000);
+    }
+    List<ByteBuffer> book_intro_array = generateBinaryVectors(num, 128);
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    //    logger.info("generateTestData" + JacksonUtil.serialize(fields));
+    return fields;
+  }
+
+  public static List<ByteBuffer> generateBinaryVectors(int count, int dimension) {
+    Random ran = new Random();
+    List<ByteBuffer> vectors = new ArrayList<>();
+    int byteCount = dimension / 8;
+    for (int n = 0; n < count; ++n) {
+      ByteBuffer vector = ByteBuffer.allocate(byteCount);
+      // logger.info("generate No."+n+" binary vector" );
+      for (int i = 0; i < byteCount; ++i) {
+        vector.put((byte) ran.nextInt(Byte.MAX_VALUE));
+        // logger.info("generateBinaryVector:"+(byte) ran.nextInt(Byte.MAX_VALUE));
+      }
+      vectors.add(vector);
+    }
+    return vectors;
+  }
+
+  public static List<InsertParam.Field> generateStringData() {
+    Random ran = new Random();
+    List<String> book_name_array = new ArrayList<>();
+    List<String> book_content_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 2000; ++i) {
+      book_name_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
+      book_content_array.add(i + "-" + MathUtil.genRandomStringAndChinese(10));
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 128; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    //    logger.info("Generate String and Chinese Data"+ JacksonUtil.serialize(fields));
+    return fields;
+  }
+
+  public static List<InsertParam.Field> generateStringPKBinaryData(int num) {
+    Random ran = new Random();
+    List<String> book_name_array = new ArrayList<>();
+    List<String> book_content_array = new ArrayList<>();
+    for (long i = 0L; i < num; ++i) {
+      book_name_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
+      book_content_array.add(i + "-" + MathUtil.genRandomStringAndChinese(10));
+    }
+    List<ByteBuffer> book_intro_array = generateBinaryVectors(num, 128);
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    //    logger.info("generateTestData" + JacksonUtil.serialize(fields));
+    return fields;
+  }
+
+  // provide extra param
+  public static String provideExtraParam(IndexType indexType) {
+    String extraParm;
+    switch (indexType) {
+      case FLAT:
+        extraParm = "{}";
+        break;
+      case IVF_FLAT:
+        extraParm = "{\"nlist\":128}";
+        break;
+      case IVF_SQ8:
+        extraParm = "{\"nlist\":128}";
+        break;
+      case IVF_PQ:
+        extraParm = "{\"nlist\":128, \"m\":16, \"nbits\":8}";
+        break;
+      case ANNOY:
+        extraParm = "{\"n_trees\":16}";
+        break;
+      case HNSW:
+        extraParm = "{\"M\":16,\"efConstruction\":64}";
+        break;
+      case RHNSW_FLAT:
+        extraParm = "{\"M\":16,\"efConstruction\":64}";
+        break;
+      case RHNSW_PQ:
+        extraParm = "{\"M\":16,\"efConstruction\":64, \"PQM\":16}";
+        break;
+      case RHNSW_SQ:
+        extraParm = "{\"M\":16,\"efConstruction\":64}";
+        break;
+      default:
+        extraParm = "";
+        break;
+    }
+    return extraParm;
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/entity/FieldType.java

@@ -0,0 +1,12 @@
+package com.zilliz.milvustest.entity;
+
+public enum FieldType {
+  PK_FIELD,
+  INT_FIELD,
+  STRING_FIELD,
+  FLOAT_FIELD,
+  BOOLEAN_FIELD,
+  FLOAT_VECTOR_FIELD,
+  LONG_FIELD,
+  STRING_PK_FIELD;
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/entity/FileBody.java

@@ -0,0 +1,12 @@
+package com.zilliz.milvustest.entity;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class FileBody {
+  private String fieldName;
+  private FieldType fieldType;
+  private List fieldValue;
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/entity/MilvusEntity.java

@@ -0,0 +1,11 @@
+package com.zilliz.milvustest.entity;
+
+import lombok.Data;
+
+@Data
+public class MilvusEntity {
+  private String Collection;
+  private String partition;
+  private String alias;
+  private String index;
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/service/ComstumerListener.java

@@ -0,0 +1,82 @@
+package com.zilliz.milvustest.service;
+
+import org.apache.log4j.Logger;
+import org.testng.ITestContext;
+import org.testng.ITestResult;
+import org.testng.TestListenerAdapter;
+
+public class ComstumerListener extends TestListenerAdapter {
+  Logger logger = Logger.getLogger(ComstumerListener.class);
+  /**
+   * 开始
+   *
+   * @param iTestContext ITestContext
+   */
+  @Override
+  public void onStart(ITestContext iTestContext) {
+    super.onStart(iTestContext);
+    logger.info(
+        String.format("====================[%s]测试开始====================", iTestContext.getName()));
+  }
+
+  /**
+   * 测试开始
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestStart(ITestResult iTestResult) {
+    super.onTestStart(iTestResult);
+    logger.info(String.format("========%s测试开始========", iTestResult.getName()));
+  }
+
+  /**
+   * 测试成功
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestSuccess(ITestResult iTestResult) {
+    super.onTestSuccess(iTestResult);
+    logger.info(String.format("========%s测试通过========", iTestResult.getName()));
+  }
+
+  /**
+   * 测试失败
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestFailure(ITestResult iTestResult) {
+    super.onTestFailure(iTestResult);
+    logger.error(
+        String.format(
+            "========%s测试失败,失败原因如下：\n%s========",
+            iTestResult.getName(), iTestResult.getThrowable()));
+
+    /** 出现异常进行截图操作，这里得要自己去实现 */
+  }
+
+  /**
+   * 测试跳过
+   *
+   * @param iTestResult ITestResult
+   */
+  @Override
+  public void onTestSkipped(ITestResult iTestResult) {
+    super.onTestSkipped(iTestResult);
+    logger.info(String.format("========%s跳过测试========", iTestResult.getName()));
+  }
+
+  /**
+   * 结束
+   *
+   * @param iTestContext ITestContext
+   */
+  @Override
+  public void onFinish(ITestContext iTestContext) {
+    super.onFinish(iTestContext);
+    logger.info(
+        String.format("====================%s测试结束====================", iTestContext.getName()));
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/service/LogRecord.java

@@ -0,0 +1,54 @@
+package com.zilliz.milvustest.service;
+
+import org.apache.log4j.Logger;
+import org.testng.ITestContext;
+import org.testng.ITestListener;
+import org.testng.ITestResult;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class LogRecord implements ITestListener {
+  Logger logger = Logger.getLogger(LogRecord.class);
+
+  @Override
+  public void onTestStart(ITestResult result) {
+    logger.info("before test: " + result.getName() + " ,start time: " + this.getCurrentTime());
+  }
+
+  public String getCurrentTime() {
+    DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss:SSS");
+    Date dt = new Date();
+    return dateFormat.format(dt);
+  }
+
+  @Override
+  public void onTestSuccess(ITestResult result) {
+    logger.info("run success: " + result.getName() + " ,run time:" + this.getCurrentTime());
+  }
+
+  @Override
+  public void onTestFailure(ITestResult result) {
+    logger.error("run failed: " + result.getName() + " ,run time:" + this.getCurrentTime());
+    logger.error(result.getMethod() + " parameters：" + result.getParameters());
+  }
+
+  @Override
+  public void onTestSkipped(ITestResult result) {
+    logger.info("skip test: " + result.getName() + " ,run time: " + this.getCurrentTime());
+  }
+
+  @Override
+  public void onTestFailedButWithinSuccessPercentage(ITestResult result) {}
+
+  @Override
+  public void onStart(ITestContext context) {
+    logger.info("start suit test: " + context.getName() + " ,run time: " + this.getCurrentTime());
+  }
+
+  @Override
+  public void onFinish(ITestContext context) {
+    logger.info("finish suit test: " + context.getName() + " ,run time: " + this.getCurrentTime());
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/util/FileUtils.java

@@ -0,0 +1,243 @@
+package com.zilliz.milvustest.util;
+
+import com.zilliz.milvustest.entity.FieldType;
+import com.zilliz.milvustest.entity.FileBody;
+import io.minio.BucketExistsArgs;
+import io.minio.MakeBucketArgs;
+import io.minio.MinioClient;
+import io.minio.UploadObjectArgs;
+import io.minio.errors.MinioException;
+import org.apache.log4j.Logger;
+
+import java.io.*;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+
+public class FileUtils {
+  public static Logger logger = Logger.getLogger(FileUtils.class);
+
+  // generate Json File
+  public static boolean createFile(
+      String jsonStr, String filePath, String fileName, String fileType) {
+    boolean flag = true;
+    String fullPath = filePath + File.separator + fileName + "." + fileType;
+    File file = new File(fullPath);
+    if (!file.getParentFile().exists()) {
+      file.getParentFile().mkdirs();
+    }
+    if (file.exists()) {
+      file.delete();
+    }
+    try {
+      file.createNewFile();
+      Writer writer = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
+      writer.write(jsonStr);
+      writer.flush();
+      writer.close();
+    } catch (IOException e) {
+      logger.error(e.getMessage());
+      flag = false;
+    }
+    return flag;
+  }
+  // generateJsonBody
+
+  public static String generateFileBody(
+      Boolean rowBased,
+      int rows,
+      int dim,
+      List<FileBody> fileBodyList,
+      Boolean autoPK,
+      int fileNumber) {
+    // init filed value
+    if (autoPK == null) {
+      autoPK = true;
+    }
+    Boolean finalAutoPK = autoPK;
+    fileBodyList.stream()
+        .forEach(
+            x -> {
+              if (x.getFieldType().equals(FieldType.PK_FIELD)) {
+                Integer[] ints = MathUtil.generateIntPK(rows, finalAutoPK, fileNumber);
+                List<Integer> integerList = Arrays.asList(ints);
+                x.setFieldValue(integerList);
+              }
+              if (x.getFieldType().equals(FieldType.INT_FIELD)) {
+                Integer[] ints = MathUtil.generateInt(rows, true);
+                List<Integer> integerList = Arrays.asList(ints);
+                x.setFieldValue(integerList);
+              }
+              if (x.getFieldType().equals(FieldType.FLOAT_FIELD)) {
+                Float[] floats = MathUtil.generateFloat(rows);
+                x.setFieldValue(Arrays.asList(floats));
+              }
+              if (x.getFieldType().equals(FieldType.STRING_FIELD)) {
+                String[] strings = MathUtil.generateString(rows);
+                x.setFieldValue(Arrays.asList(strings));
+              }
+              if (x.getFieldType().equals(FieldType.BOOLEAN_FIELD)) {
+                Boolean[] booleans = MathUtil.generateBoolean(rows);
+                x.setFieldValue(Arrays.asList(booleans));
+              }
+              if (x.getFieldType().equals(FieldType.LONG_FIELD)) {
+                Long[] longs = MathUtil.generateLong(rows);
+                x.setFieldValue(Arrays.asList(longs));
+              }
+              if (x.getFieldType().equals(FieldType.FLOAT_VECTOR_FIELD)) {
+                List<Double[]> doubesList = MathUtil.generateFloatVector(rows, 20, dim);
+                x.setFieldValue(doubesList);
+              }
+              if (x.getFieldType().equals(FieldType.STRING_PK_FIELD)) {
+                String[] strings = MathUtil.generateString(rows);
+                x.setFieldValue(Arrays.asList(strings));
+              }
+            });
+    if (rowBased) {
+
+      List<Map> rowsList = new ArrayList<>();
+      for (int r = 0; r < rows; r++) {
+        Map map = new HashMap();
+        for (int i = 0; i < fileBodyList.size(); i++) {
+          map.put(fileBodyList.get(i).getFieldName(), fileBodyList.get(i).getFieldValue().get(r));
+        }
+        rowsList.add(map);
+      }
+      HashMap rowsMap = new HashMap();
+      rowsMap.put("rows", rowsList);
+      return JacksonUtil.serialize(rowsMap);
+    } else {
+      HashMap map = new HashMap();
+      fileBodyList.stream()
+          .forEach(
+              x -> {
+                map.put(x.getFieldName(), x.getFieldValue());
+              });
+      return JacksonUtil.serialize(map);
+    }
+  }
+
+  /**
+   * @param rowBased: true-rows_file,false-column_file,
+   * @param rows: the numbers of entities to be generated in the file
+   * @param dim: dim of the vector data
+   * @param fileBodyList: entity of FileBody
+   * @param autoPK: generate PK sequence or not
+   * @param filePath: specify file path
+   * @param fileName: specify file name
+   * @param fileType: specify the file suffix
+   * @param fileNums: generate the number of files
+   * @return
+   */
+  public static Boolean generateMultipleFiles(
+      Boolean rowBased,
+      int rows,
+      int dim,
+      List<FileBody> fileBodyList,
+      Boolean autoPK,
+      String filePath,
+      String fileName,
+      String fileType,
+      int fileNums) {
+    Boolean resultFlag = true;
+    for (int i = 0; i < fileNums; i++) {
+      String s = generateFileBody(rowBased, rows, dim, fileBodyList, autoPK, i + 1);
+      s = JacksonUtil.formatJson(s);
+      boolean file = createFile(s, filePath, fileName + i, fileType);
+      if (!file) {
+        resultFlag = false;
+      }
+    }
+    return resultFlag;
+  }
+
+  public static void fileUploader(String path, String fileName, String bucketFolder)
+      throws IOException, NoSuchAlgorithmException, InvalidKeyException {
+    if (bucketFolder == null) bucketFolder = "";
+    try {
+      // Create a minioClient with the MinIO server playground, its access key and secret key.
+      MinioClient minioClient =
+          MinioClient.builder()
+              .endpoint(PropertyFilesUtil.getRunValue("minioHost"))
+              .credentials(
+                  PropertyFilesUtil.getRunValue("accesskey"),
+                  PropertyFilesUtil.getRunValue("secretkey"))
+              .build();
+
+      // Make 'jsonBucket' bucket if not exist.
+      boolean found =
+          minioClient.bucketExists(BucketExistsArgs.builder().bucket("milvus-bucket").build());
+      if (!found) {
+        // Make a new bucket called 'jsonBucket'.
+        minioClient.makeBucket(MakeBucketArgs.builder().bucket("milvus-bucket").build());
+      } else {
+        System.out.println("Bucket 'milvus-bucket' already exists.");
+      }
+
+      // Upload './src/test/java/resources/autojson/jsonData0.json' as object name 'jsonData0.json'
+      // to bucket
+      minioClient.uploadObject(
+          UploadObjectArgs.builder()
+              .bucket("milvus-bucket")
+              .object(bucketFolder + "/" + fileName)
+              .filename(path + fileName)
+              .build());
+      System.out.println(
+          "'"
+              + path
+              + fileName
+              + "' is successfully uploaded as "
+              + "object '"
+              + fileName
+              + "' to bucket 'milvus-bucket'.");
+    } catch (MinioException e) {
+      System.out.println("Error occurred: " + e);
+      System.out.println("HTTP trace: " + e.httpTrace());
+    }
+  }
+
+  public static void multiFilesUpload(String path, List<String> fileNameList, String bucketFolder)
+      throws IOException, NoSuchAlgorithmException, InvalidKeyException {
+    if (bucketFolder == null) bucketFolder = "";
+    try {
+      // Create a minioClient with the MinIO server playground, its access key and secret key.
+      MinioClient minioClient =
+          MinioClient.builder()
+              .endpoint(PropertyFilesUtil.getRunValue("minioHost"))
+              .credentials(
+                  PropertyFilesUtil.getRunValue("accesskey"),
+                  PropertyFilesUtil.getRunValue("secretkey"))
+              .build();
+
+      // Make 'jsonBucket' bucket if not exist.
+      boolean found =
+          minioClient.bucketExists(BucketExistsArgs.builder().bucket("milvus-bucket").build());
+      if (!found) {
+        // Make a new bucket called 'jsonBucket'.
+        minioClient.makeBucket(MakeBucketArgs.builder().bucket("milvus-bucket").build());
+      } else {
+        System.out.println("Bucket 'milvus-bucket' already exists.");
+      }
+
+      for (String fileName : fileNameList) {
+        minioClient.uploadObject(
+            UploadObjectArgs.builder()
+                .bucket("milvus-bucket")
+                .object(bucketFolder + "/" + fileName)
+                .filename(path + fileName)
+                .build());
+        System.out.println(
+            "'"
+                + path
+                + fileName
+                + "' is successfully uploaded as "
+                + "object '"
+                + fileName
+                + "' to bucket 'milvus-bucket'.");
+      }
+    } catch (MinioException e) {
+      System.out.println("Error occurred: " + e);
+      System.out.println("HTTP trace: " + e.httpTrace());
+    }
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/util/JacksonUtil.java

@@ -0,0 +1,75 @@
+package com.zilliz.milvustest.util;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class JacksonUtil {
+
+  public static <T> T deserialize(String jsonStr, Class<T> clazz) {
+    ObjectMapper mapper = new ObjectMapper();
+    try {
+      return mapper.readValue(jsonStr, clazz);
+    } catch (JsonProcessingException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public static String serialize(Object obj) {
+    ObjectMapper mapper = new ObjectMapper();
+    try {
+      return mapper.writeValueAsString(obj);
+    } catch (JsonProcessingException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public static String formatJson(String json) {
+    String SPACE = "   ";
+    StringBuffer result = new StringBuffer();
+    int length = json.length();
+    int number = 0;
+    char key = 0;
+    for (int i = 0; i < length; i++) {
+      key = json.charAt(i);
+      if ((key == '[') || (key == '{')) {
+
+        if ((i - 1 > 0) && (json.charAt(i - 1) == ':')) {
+          result.append('\n');
+          result.append(indent(number));
+        }
+        result.append(key);
+        result.append('\n');
+        number++;
+        result.append(indent(number));
+        continue;
+      }
+      if ((key == ']') || (key == '}')) {
+        result.append('\n');
+        number--;
+        result.append(indent(number));
+        result.append(key);
+        if (((i + 1) < length) && (json.charAt(i + 1) != ',')) {
+          result.append('\n');
+        }
+        continue;
+      }
+      if ((key == ',')) {
+        result.append(key);
+        result.append('\n');
+        result.append(indent(number));
+        continue;
+      }
+      result.append(key);
+    }
+    return result.toString();
+  }
+
+  private static String indent(int number) {
+    String SPACE = "   ";
+    StringBuffer result = new StringBuffer();
+    for (int i = 0; i < number; i++) {
+      result.append(SPACE);
+    }
+    return result.toString();
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/util/MathUtil.java

@@ -0,0 +1,183 @@
+package com.zilliz.milvustest.util;
+
+import java.io.File;
+import java.math.BigDecimal;
+import java.util.*;
+
+public class MathUtil {
+  public static String getRandomString(int length) {
+    String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    Random random = new Random();
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i < length; i++) {
+      int number = random.nextInt(62);
+      sb.append(str.charAt(number));
+    }
+    return sb.toString();
+  }
+
+  public static boolean delAllFile(String path) {
+    boolean flag = false;
+    File file = new File(path);
+    if (!file.exists()) {
+      return flag;
+    }
+    if (!file.isDirectory()) {
+      return flag;
+    }
+    String[] tempList = file.list();
+    File temp = null;
+    for (int i = 0; i < tempList.length; i++) {
+      if (path.endsWith(File.separator)) {
+        temp = new File(path + tempList[i]);
+      } else {
+        temp = new File(path + File.separator + tempList[i]);
+      }
+      if (temp.isFile()) {
+        temp.delete();
+      }
+      if (temp.isDirectory()) {
+        delAllFile(path + "/" + tempList[i]); // 先删除文件夹里面的文件
+        flag = true;
+      }
+    }
+    return flag;
+  }
+
+  public static Integer[] generateIntPK(int num, Boolean sequence, int fileNumber) {
+    Integer[] intData = new Integer[num];
+    Random random = new Random(num);
+    if (sequence) {
+      for (int i = 0; i < num; i++) {
+        intData[i] = i + num * (fileNumber - 1);
+      }
+    }
+    if (!sequence) {
+      List<Integer> lists = new ArrayList<>();
+      for (int i = 0; i < num; i++) {
+        lists.add(i + num * (fileNumber - 1));
+      }
+      for (int i = 0; i < num; i++) {
+        int index = random.nextInt(lists.size());
+        intData[i] = lists.get(index);
+        lists.remove(index);
+      }
+    }
+    return intData;
+  }
+
+  public static Integer[] generateInt(int num, Boolean sequence) {
+    Integer[] intData = new Integer[num];
+    Random random = new Random(num);
+    if (sequence) {
+      for (int i = 0; i < num; i++) {
+        intData[i] = i;
+      }
+    }
+    if (!sequence) {
+      List<Integer> lists = new ArrayList<>();
+      for (int i = 0; i < num; i++) {
+        lists.add(i);
+      }
+      for (int i = 0; i < num; i++) {
+        int index = random.nextInt(lists.size());
+        intData[i] = lists.get(index);
+        lists.remove(index);
+      }
+    }
+    return intData;
+  }
+
+  public static Float[] generateFloat(int num) {
+    Float[] floats = new Float[num];
+    Random random = new Random(num);
+    for (int i = 0; i < num; i++) {
+      floats[i] = random.nextFloat();
+    }
+    return floats;
+  }
+
+  public static String[] generateString(int num) {
+    String[] strings = new String[num];
+    for (int i = 0; i < num; i++) {
+      strings[i] = getRandomString(15);
+    }
+    return strings;
+  }
+
+  public static List<Double[]> generateFloatVector(int num, int length, int dim) {
+    List<Double[]> doubleList = new ArrayList<>(num);
+    for (int j = 0; j < num; j++) {
+      Double[] doubles = new Double[dim];
+      for (int i = 0; i < dim; i++) {
+        BigDecimal bigDecimal = BigDecimal.valueOf(Math.random());
+        BigDecimal bigDecimal1 = bigDecimal.setScale(length, BigDecimal.ROUND_HALF_UP);
+        doubles[i] = bigDecimal1.doubleValue();
+      }
+      doubleList.add(doubles);
+    }
+    return doubleList;
+  }
+
+  public static Boolean[] generateBoolean(int num) {
+    Boolean[] booleans = new Boolean[num];
+    Random random = new Random();
+    for (int i = 0; i < num; i++) {
+      if (random.nextInt() % 2 == 0) {
+        booleans[i] = Boolean.TRUE;
+      } else {
+        booleans[i] = Boolean.FALSE;
+      }
+    }
+    return booleans;
+  }
+
+  public static Long[] generateLong(int num) {
+    Long[] longs = new Long[num];
+    Random random = new Random();
+    for (int i = 0; i < num; i++) {
+      longs[i] = random.nextLong();
+    }
+    return longs;
+  }
+
+  public static Object[][] combine(Object[][] a1, Object[][] a2) {
+    List<Object[]> objectCodesList = new LinkedList<Object[]>();
+    for (Object[] o : a1) {
+      for (Object[] o2 : a2) {
+        objectCodesList.add(concatAll(o, o2));
+      }
+    }
+    return objectCodesList.toArray(new Object[0][0]);
+  }
+
+  public static <T> T[] concatAll(T[] first, T[]... rest) {
+    // calculate the total length of the final object array after the concat
+    int totalLength = first.length;
+    for (T[] array : rest) {
+      totalLength += array.length;
+    }
+    // copy the first array to result array and then copy each array completely to result
+    T[] result = Arrays.copyOf(first, totalLength);
+    int offset = first.length;
+    for (T[] array : rest) {
+      System.arraycopy(array, 0, result, offset, array.length);
+      offset += array.length;
+    }
+
+    return result;
+  }
+
+  public static String genRandomStringAndChinese(int length){
+    String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    String chinese="富强民主文明和谐自由平等公正法治爱国敬业诚信友善";
+    String strChinese=str+chinese;
+    Random random = new Random();
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i < length; i++) {
+      int number = random.nextInt(strChinese.length());
+      sb.append(strChinese.charAt(number));
+    }
+    return sb.toString();
+  }
+}

tests/milvustest/src/main/java/com/zilliz/milvustest/util/PropertyFilesUtil.java

@@ -0,0 +1,40 @@
+package com.zilliz.milvustest.util;
+
+import org.apache.log4j.Logger;
+
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Properties;
+
+public class PropertyFilesUtil {
+  static Logger logger = Logger.getLogger(PropertyFilesUtil.class);
+
+  public static HashMap<String, String> readPropertyFile(String propertyFileName) {
+    HashMap<String, String> hashMap = new HashMap<>();
+    Properties prop = new Properties();
+    try {
+      InputStream in = new BufferedInputStream(new FileInputStream(propertyFileName));
+      prop.load(in); // /加载属性列表
+      Iterator<String> it = prop.stringPropertyNames().iterator();
+      while (it.hasNext()) {
+        String key = it.next();
+        hashMap.put(key, prop.getProperty(key));
+      }
+      in.close();
+    } catch (Exception e) {
+      logger.error(e.getMessage());
+    }
+    return hashMap;
+  }
+
+  public static String getRunValue(String key) {
+    HashMap<String, String> hashMap =
+        PropertyFilesUtil.readPropertyFile("./src/test/java/resources/run.properties");
+    String value = "";
+    value = hashMap.get(key);
+    return value;
+  }
+}

tests/milvustest/src/main/resources/application.properties

@@ -0,0 +1 @@
+

tests/milvustest/src/main/resources/log4j.properties

@@ -0,0 +1,21 @@
+### 设置###
+log4j.rootLogger=debug,stdout,D,E
+### 输出信息到控制台 ###
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
+### 输出INFO 级别以上的日志到日志文件 ###
+log4j.appender.D=org.apache.log4j.DailyRollingFileAppender
+log4j.appender.D.File=./logs/info.log
+log4j.appender.D.Append=true
+log4j.appender.D.Threshold=INFO
+log4j.appender.D.layout=org.apache.log4j.PatternLayout
+log4j.appender.D.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
+### 输出ERROR 级别以上的日志到日志文件 ###
+log4j.appender.E=org.apache.log4j.DailyRollingFileAppender
+log4j.appender.E.File=./logs/error.log
+log4j.appender.E.Append=true
+log4j.appender.E.Threshold=ERROR
+log4j.appender.E.layout=org.apache.log4j.PatternLayout
+log4j.appender.E.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n

tests/milvustest/src/test/java/com/zilliz/milvustest/MilvustestApplicationTests.java

@@ -0,0 +1,11 @@
+package com.zilliz.milvustest;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class MilvustestApplicationTests {
+
+  @Test
+  void contextLoads() {}
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/alias/AlterAliasTest.java

@@ -0,0 +1,86 @@
+package com.zilliz.milvustest.alias;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.alias.AlterAliasParam;
+import io.milvus.param.alias.CreateAliasParam;
+import io.milvus.param.alias.DropAliasParam;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import lombok.NonNull;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Alias")
+@Feature("AlterAlias")
+public class AlterAliasTest extends BaseTest {
+  private String aliasStr;
+  private String collectionStr;
+
+  @BeforeClass
+  public void initData() {
+    aliasStr = "alias_" + MathUtil.getRandomString(10);
+    milvusClient.createAlias(
+        CreateAliasParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withAlias(aliasStr)
+            .build());
+    collectionStr = CommonFunction.createNewCollection();
+  }
+
+  @AfterClass
+  public void dropAlias() {
+    milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(aliasStr).build());
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collectionStr).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Alter alias to anther collection")
+  public void alterAliasTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.alterAlias(
+            AlterAliasParam.newBuilder()
+                .withCollectionName(collectionStr)
+                .withAlias(aliasStr)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "query after Alter alias",dependsOnMethods = "alterAliasTest")
+  public void queryAfterAlterAlias(){
+    milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(aliasStr)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(queryResultsR.getException().getMessage().contains("checkIfLoaded failed when query"));
+
+  }
+
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/alias/CreateAliasTest.java

@@ -0,0 +1,81 @@
+package com.zilliz.milvustest.alias;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.alias.CreateAliasParam;
+import io.milvus.param.alias.DropAliasParam;
+import io.milvus.param.collection.DescribeCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.control.GetQuerySegmentInfoParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import lombok.NonNull;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Alias")
+@Feature("CreateAlias")
+public class CreateAliasTest extends BaseTest {
+  private String aliasStr;
+
+  @BeforeClass
+  public void initData() {
+    aliasStr = "alias_" + MathUtil.getRandomString(10);
+  }
+
+  @AfterClass
+  public void dropAlias() {
+    milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(aliasStr).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Create alias for collection")
+  public void createAliasTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createAlias(
+            CreateAliasParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withAlias(aliasStr)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "query collection with alias",dependsOnMethods = "createAliasTest")
+  public void queryWithAlias() {
+    milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(aliasStr)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+
+  }
+
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/alias/DropAliasTest.java

@@ -0,0 +1,66 @@
+package com.zilliz.milvustest.alias;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.alias.CreateAliasParam;
+import io.milvus.param.alias.DropAliasParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Alias")
+@Feature("DropAlias")
+public class DropAliasTest extends BaseTest {
+  private String aliasStr;
+
+  @BeforeClass
+  public void initData() {
+    aliasStr = "alias_" + MathUtil.getRandomString(10);
+    milvusClient.createAlias(
+        CreateAliasParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withAlias(aliasStr)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "drop alias")
+  public void dropAlias() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(aliasStr).build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "query after drop alias", dependsOnMethods = "dropAlias")
+  public void queryAfterDropAlias() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(aliasStr)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        queryResultsR.getException().getMessage(),"DescribeCollection failed: can't find collection: "+aliasStr);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/businessflow/BigFileBulkLoadTest.java

@@ -0,0 +1,230 @@
+/*
+package com.zilliz.milvustest.businessflow;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.entity.FileBody;
+import com.zilliz.milvustest.util.FileUtils;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.*;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.*;
+import io.milvus.param.dml.BulkloadParam;
+import io.milvus.param.dml.GetBulkloadStateParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.response.GetCollStatResponseWrapper;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Issue;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+*/
+/**
+ * @Author yongpeng.li @Date 2022/6/2 2:00 PM
+ *//*
+
+   public class BigFileBulkLoadTest extends BaseTest {
+       @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/301")
+       @Test(description = "Big file bulk load test")
+       public void BigFileBulkLoadTest1() throws IOException, NoSuchAlgorithmException, InvalidKeyException, InterruptedException {
+           //create collection
+           String newColltcion = CommonFunction.createNewCollection();
+           milvusClient.createPartition(CreatePartitionParam.newBuilder().withCollectionName(newColltcion)
+                   .withPartitionName(CommonData.defaultPartition)
+                   .build());
+           // create index
+           milvusClient.createIndex(CreateIndexParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .withFieldName(CommonData.defaultVectorField)
+                   .withIndexName(CommonData.defaultIndex)
+                   .withMetricType(MetricType.L2)
+                   .withIndexType(IndexType.IVF_FLAT)
+                   .withExtraParam(CommonData.defaultExtraParam)
+                   .withSyncMode(Boolean.FALSE)
+                   .build());
+           //generate json files
+           String path = CommonData.defaultBulkLoadPath;
+           List<FileBody> fileBodyList = CommonFunction.generateDefaultFileBody();
+           int rows=5000;
+           Boolean aBoolean = FileUtils.generateMultipleFiles(true, rows, 128, fileBodyList, true
+                   , path, "bigJson", "json", 1);
+           System.out.println(aBoolean);
+           // upload json to minio
+           FileUtils.fileUploader(path,"bigJson0.json","bigData");
+           long startTime = System.currentTimeMillis();
+           // bulk load
+           R<ImportResponse> bulkload = milvusClient.bulkload(BulkloadParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .addFile("bigData/bigJson0.json").withRowBased(true)
+                   .build());
+           softAssert.assertEquals(bulkload.getStatus().intValue(),0);
+           softAssert.assertEquals(bulkload.getData().getTasksCount(),1);
+           ImportResponse data = bulkload.getData();
+           Long taskId=data.getTasks(0);
+           R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                   .withTaskID(taskId).build());
+           softAssert.assertEquals(bulkloadState.getStatus().intValue(),0);
+           // check state
+           int i=0;
+           while (i<100){
+               R<GetImportStateResponse> reGetState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                       .withTaskID(taskId).build());
+               GetImportStateResponse data1 = reGetState.getData();
+               System.out.println("current state:"+data1.getStateValue()+"-"+data1.getState());
+               if(data1.getStateValue()==5){
+                   softAssert.assertEquals(data1.getRowCount(),rows);
+                   long finish = System.currentTimeMillis();
+                   long elapsedTime=finish-startTime;
+                   System.out.println("Import big data file use:"+elapsedTime+"ms");
+                   System.out.println("expected rows:"+rows+",actual rows:"+data1.getRowCount());
+                   break;
+               }
+               Thread.sleep(5000);
+               i++;
+               if(i==100||data1.getStateValue()==1){
+                   softAssert.assertEquals(data1.getStatus().toString(),"ImportPersisted","importFailed!!");
+               }
+           }
+           Thread.sleep(5000);
+           //query collection info
+           R<GetCollectionStatisticsResponse> collectionStatistics = milvusClient.getCollectionStatistics(GetCollectionStatisticsParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .withFlush(true).build());
+           softAssert.assertEquals(collectionStatistics.getStatus().intValue(),0);
+           GetCollStatResponseWrapper getCollStatResponseWrapper = new GetCollStatResponseWrapper(collectionStatistics.getData());
+           System.out.println("rows count of "+newColltcion+"is:"+getCollStatResponseWrapper.getRowCount());
+           softAssert.assertEquals(getCollStatResponseWrapper.getRowCount(),rows);
+           // load
+           R<RpcStatus> rpcStatusR = milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(newColltcion).build());
+           softAssert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+           softAssert.assertEquals(rpcStatusR.getData().getMsg(),"Success");
+
+           //search
+
+           //query
+           String query_Param = "book_id  in [2,4,6,8]";
+           List<String> outFields=Arrays.asList("book_id","word_count");
+           QueryParam queryParam= QueryParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .withOutFields(outFields)
+                   .withExpr(query_Param)
+                   .build();
+           R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+           QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+           softAssert.assertEquals(queryResultsR.getStatus().intValue(),0);
+           softAssert.assertEquals(queryResultsR.getData().getFieldsDataCount(),2);
+           softAssert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(),4);
+           System.out.println("query book_id:"+wrapperQuery.getFieldWrapper("book_id").getFieldData());
+           System.out.println("query word_count:"+wrapperQuery.getFieldWrapper("word_count").getFieldData());
+           //release
+           milvusClient.releaseCollection(ReleaseCollectionParam.newBuilder().withCollectionName(newColltcion).build());
+           milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(newColltcion).build());
+           softAssert.assertAll();
+       }
+
+       @Test(description = "Big json file bulk load test after create index and load")
+       public void bigJsonFileBulkLoadTest2() throws InterruptedException {
+           //create collection
+           String newColltcion = CommonFunction.createNewCollection();
+           milvusClient.createPartition(CreatePartitionParam.newBuilder().withCollectionName(newColltcion)
+                   .withPartitionName(CommonData.defaultPartition)
+                   .build());
+           // create index
+           milvusClient.createIndex(CreateIndexParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .withFieldName(CommonData.defaultVectorField)
+                   .withIndexName(CommonData.defaultIndex)
+                   .withMetricType(MetricType.L2)
+                   .withIndexType(IndexType.IVF_FLAT)
+                   .withExtraParam(CommonData.defaultExtraParam)
+                   .withSyncMode(Boolean.FALSE)
+                   .build());
+           // load collection
+           R<RpcStatus> rpcStatusR = milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(newColltcion).withSyncLoad(false).build());
+           softAssert.assertEquals(rpcStatusR.getStatus().intValue(),0);
+           softAssert.assertEquals(rpcStatusR.getData().getMsg(),"Success");
+           long startTime = System.currentTimeMillis();
+           // bulk load
+           int rows=5000;
+           R<ImportResponse> bulkload = milvusClient.bulkload(BulkloadParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .addFile("bigData/bigJson0.json").withRowBased(true)
+                   .build());
+           softAssert.assertEquals(bulkload.getStatus().intValue(),0);
+           softAssert.assertEquals(bulkload.getData().getTasksCount(),1);
+           ImportResponse data = bulkload.getData();
+           Long taskId=data.getTasks(0);
+           R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                   .withTaskID(taskId).build());
+           softAssert.assertEquals(bulkloadState.getStatus().intValue(),0);
+           // check state
+           int i=0;
+           while (i<100){
+               R<GetImportStateResponse> reGetState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                       .withTaskID(taskId).build());
+               GetImportStateResponse data1 = reGetState.getData();
+               System.out.println("current state:"+data1.getStateValue()+"-"+data1.getState());
+               if(data1.getStateValue()==5){
+                   softAssert.assertEquals(data1.getRowCount(),rows);
+                   long finish = System.currentTimeMillis();
+                   long elapsedTime=finish-startTime;
+                   System.out.println("Import big data file use:"+elapsedTime+"ms");
+                   System.out.println("expected rows:"+rows+",actual rows:"+data1.getRowCount());
+                   break;
+               }
+               Thread.sleep(5000);
+               i++;
+               if(i==100||data1.getStateValue()==1){
+                   softAssert.assertEquals(data1.getStatus().toString(),"ImportPersisted","importFailed!!");
+               }
+           }
+           Thread.sleep(120000);
+           //query collection info
+           R<GetCollectionStatisticsResponse> collectionStatistics = milvusClient.getCollectionStatistics(GetCollectionStatisticsParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .withFlush(true).build());
+           softAssert.assertEquals(collectionStatistics.getStatus().intValue(),0);
+           GetCollStatResponseWrapper getCollStatResponseWrapper = new GetCollStatResponseWrapper(collectionStatistics.getData());
+           System.out.println("rows count of "+newColltcion+"is:"+getCollStatResponseWrapper.getRowCount());
+           softAssert.assertEquals(getCollStatResponseWrapper.getRowCount(),rows);
+           //query
+           String query_Param = "book_id  in [2,4,6,8]";
+           List<String> outFields=Arrays.asList("book_id","word_count");
+           QueryParam queryParam= QueryParam.newBuilder()
+                   .withCollectionName(newColltcion)
+                   .withOutFields(outFields)
+                   .withExpr(query_Param)
+                   .build();
+           R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+           QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+           softAssert.assertEquals(queryResultsR.getStatus().intValue(),0);
+           softAssert.assertEquals(queryResultsR.getData().getFieldsDataCount(),2);
+           softAssert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(),4);
+           System.out.println("query book_id:"+wrapperQuery.getFieldWrapper("book_id").getFieldData());
+           System.out.println("query word_count:"+wrapperQuery.getFieldWrapper("word_count").getFieldData());
+           //release
+           milvusClient.releaseCollection(ReleaseCollectionParam.newBuilder().withCollectionName(newColltcion).build());
+           milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(newColltcion).build());
+           softAssert.assertAll();
+       }
+
+
+   }
+   */

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/CreateCollectionTest.java

@@ -0,0 +1,234 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.DataType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.CreateCollectionParam;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.FieldType;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("CreateCollection")
+public class CreateCollectionTest extends BaseTest {
+  public String commonCollection;
+  public String binaryVectorCollection;
+
+  public String stringPKCollection;
+
+  @DataProvider(name = "collectionByDataProvider")
+  public Object[][] provideCollectionName() {
+    return new String[][] {{"collection_" + MathUtil.getRandomString(10)}};
+  }
+
+  @AfterClass(description = "delete test datas after CreateCollectionTest")
+  public void deleteTestData() {
+    if (commonCollection != null) {
+      milvusClient.dropCollection(
+          DropCollectionParam.newBuilder().withCollectionName(commonCollection).build());
+    }
+    if (binaryVectorCollection != null) {
+      milvusClient.dropCollection(
+          DropCollectionParam.newBuilder().withCollectionName(binaryVectorCollection).build());
+    }
+    if (stringPKCollection != null) {
+      milvusClient.dropCollection(
+          DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+    }
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Create collection success", dataProvider = "collectionByDataProvider")
+  public void createCollectionSuccess(String collectionName) {
+    commonCollection = collectionName;
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test " + collectionName + " search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+    Assert.assertEquals(collection.getStatus().toString(), "0");
+    Assert.assertEquals(collection.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "Repeat create collection",
+      dependsOnMethods = {"createCollectionSuccess"})
+  public void createCollectionRepeat() {
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.FloatVector)
+            .withDimension(2)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(commonCollection)
+            .withDescription("Test" + commonCollection + "search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+    Assert.assertEquals(collection.getStatus().toString(), "1");
+    Assert.assertEquals(
+        collection.getException().getMessage(),
+        "CreateCollection failed: meta table add collection failed,error = collection "
+            + commonCollection
+            + " exist");
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "Create collection without params", expectedExceptions = ParamException.class)
+  public void createCollectionWithoutCollectionName() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createCollection(CreateCollectionParam.newBuilder().build());
+    System.out.println(rpcStatusR);
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Create binary vector collection", dataProvider = "collectionByDataProvider")
+  public void createBinaryVectorCollection(String collectionName) {
+    binaryVectorCollection = collectionName;
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(DataType.Int64)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.BinaryVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test " + collectionName + " search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+    Assert.assertEquals(collection.getStatus().toString(), "0");
+    Assert.assertEquals(collection.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Create String collection", dataProvider = "collectionByDataProvider")
+  public void createStringPKCollection(String collectionName) {
+    stringPKCollection = collectionName;
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_name")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(20)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder()
+            .withName("book_content")
+            .withDataType(DataType.VarChar)
+            .withMaxLength(10)
+            .build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(DataType.FloatVector)
+            .withDimension(128)
+            .build();
+    CreateCollectionParam createCollectionReq =
+        CreateCollectionParam.newBuilder()
+            .withCollectionName(collectionName)
+            .withDescription("Test " + collectionName + " search")
+            .withShardsNum(2)
+            .addFieldType(fieldType1)
+            .addFieldType(fieldType2)
+            .addFieldType(fieldType3)
+            .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+    Assert.assertEquals(collection.getStatus().toString(), "0");
+    Assert.assertEquals(collection.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Create String collection without max length", dataProvider = "collectionByDataProvider", expectedExceptions = ParamException.class)
+  public void createStringPKCollectionWithoutMaxLength(String collectionName) {
+    FieldType fieldType1 =
+            FieldType.newBuilder()
+                    .withName("book_name")
+                    .withDataType(DataType.VarChar)
+                    .withPrimaryKey(true)
+                    .withAutoID(false)
+                    .build();
+    FieldType fieldType2 =
+            FieldType.newBuilder()
+                    .withName("book_content")
+                    .withDataType(DataType.VarChar)
+                    .build();
+    FieldType fieldType3 =
+            FieldType.newBuilder()
+                    .withName("book_intro")
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(128)
+                    .build();
+    CreateCollectionParam createCollectionReq =
+            CreateCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .withDescription("Test " + collectionName + " search")
+                    .withShardsNum(2)
+                    .addFieldType(fieldType1)
+                    .addFieldType(fieldType2)
+                    .addFieldType(fieldType3)
+                    .build();
+    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+    Assert.assertEquals(collection.getStatus().toString(), "1");
+    Assert.assertEquals(collection.getData().getMsg(), "Varchar field max length must be specified");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/DescribeCollectionTest.java

@@ -0,0 +1,37 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.DescribeCollectionResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.DescribeCollectionParam;
+import io.milvus.response.DescCollResponseWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("DescribeCollection")
+public class DescribeCollectionTest extends BaseTest {
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "query the name and schema of the collection")
+  public void describeCollectionTest() {
+    R<DescribeCollectionResponse> respDescribeCollection =
+        milvusClient.describeCollection( // Return the name and schema of the collection.
+            DescribeCollectionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    System.out.println(respDescribeCollection);
+    Assert.assertEquals(respDescribeCollection.getStatus().intValue(), 0);
+    DescribeCollectionResponse respDescribeCollectionData = respDescribeCollection.getData();
+    DescCollResponseWrapper descCollResponseWrapper =
+        new DescCollResponseWrapper(respDescribeCollectionData);
+    System.out.println(descCollResponseWrapper);
+    Assert.assertEquals(descCollResponseWrapper.getCollectionName(), CommonData.defaultCollection);
+    Assert.assertEquals(descCollResponseWrapper.getFields().size(), 3);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/DropCollectionTest.java

@@ -0,0 +1,51 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("DropCollection")
+public class DropCollectionTest extends BaseTest {
+  public String commonCollection;
+
+  @BeforeClass(description = "Create collection before test")
+  public void provideCollectionName() {
+    String newCollection = CommonFunction.createNewCollection();
+    commonCollection = newCollection;
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "drop collection")
+  public void dropCollectionSuccess() {
+    DropCollectionParam build =
+        DropCollectionParam.newBuilder().withCollectionName(commonCollection).build();
+    R<RpcStatus> rpcStatusR = milvusClient.dropCollection(build);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // TODO:校验load之后
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "drop illegal collection")
+  public void dropIllegalCollection() {
+    String collection = "collection_" + MathUtil.getRandomString(10);
+    DropCollectionParam build =
+        DropCollectionParam.newBuilder().withCollectionName(collection).build();
+    R<RpcStatus> rpcStatusR = milvusClient.dropCollection(build);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        rpcStatusR.getException().getMessage(),
+        "DescribeCollection failed: can't find collection: " + collection + "");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/GetCollectionStatisticsTest.java

@@ -0,0 +1,53 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.GetCollectionStatisticsResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.GetCollectionStatisticsParam;
+import io.milvus.response.GetCollStatResponseWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("GetCollectionStatistics")
+public class GetCollectionStatisticsTest extends BaseTest {
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Shows the statistics information of a collection.")
+  public void getCollectionStatisticsInfo() {
+    R<GetCollectionStatisticsResponse> respCollectionStatistics =
+        milvusClient
+            .getCollectionStatistics( // Return the statistics information of the collection.
+                GetCollectionStatisticsParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withFlush(false)
+                    .build());
+    Assert.assertEquals(respCollectionStatistics.getStatus().intValue(), 0);
+    GetCollStatResponseWrapper wrapperCollectionStatistics =
+        new GetCollStatResponseWrapper(respCollectionStatistics.getData());
+    Assert.assertEquals(wrapperCollectionStatistics.getRowCount(), 0);
+    System.out.println(wrapperCollectionStatistics);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Shows the statistics information of a collection with flush")
+  public void getCollectionStatisticsWithFlushTest() {
+    R<GetCollectionStatisticsResponse> respCollectionStatistics =
+        milvusClient
+            .getCollectionStatistics( // Return the statistics information of the collection.
+                GetCollectionStatisticsParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withFlush(true)
+                    .build());
+    Assert.assertEquals(respCollectionStatistics.getStatus().intValue(), 0);
+    GetCollStatResponseWrapper wrapperCollectionStatistics =
+        new GetCollStatResponseWrapper(respCollectionStatistics.getData());
+    Assert.assertEquals(wrapperCollectionStatistics.getRowCount(), 2000);
+    System.out.println(wrapperCollectionStatistics);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/HasCollectionTest.java

@@ -0,0 +1,40 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.param.R;
+import io.milvus.param.collection.HasCollectionParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("HasCollection")
+public class HasCollectionTest extends BaseTest {
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Check collection is existent")
+  public void hasCollectionTest() {
+    R<Boolean> respHasCollection =
+        milvusClient.hasCollection(
+            HasCollectionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    Assert.assertEquals(respHasCollection.getData(), Boolean.TRUE);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Check collection is not existent")
+  public void hasNoExistentCollectionTest() {
+    R<Boolean> respHasCollection =
+        milvusClient.hasCollection(
+            HasCollectionParam.newBuilder()
+                .withCollectionName("collection" + MathUtil.getRandomString(10))
+                .build());
+    Assert.assertEquals(respHasCollection.getData(), Boolean.FALSE);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/LoadCollectionTest.java

@@ -0,0 +1,69 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("LoadCollection")
+public class LoadCollectionTest extends BaseTest {
+  private String collection;
+
+  @BeforeClass(description = "create new collection")
+  public void createCollection() {
+    collection = CommonFunction.createNewCollection();
+  }
+
+  @AfterClass(description = "delete test collection")
+  public void dropCollection() {
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @AfterMethod(description = "release collection")
+  public void releaseCollection() {
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "load collection with default param")
+  public void loadCollection() {
+    LoadCollectionParam loadCollectionParam =
+        new LoadCollectionParam(
+            LoadCollectionParam.newBuilder()
+                .withCollectionName(collection)
+                .withSyncLoad(Boolean.TRUE)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .withSyncLoadWaitingInterval(500L));
+    R<RpcStatus> rpcStatusR = milvusClient.loadCollection(loadCollectionParam);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "load collection Async")
+  public void loadCollectionWithAsync() {
+    LoadCollectionParam loadCollectionParam =
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(collection)
+            .withSyncLoad(Boolean.FALSE)
+            .build();
+    R<RpcStatus> rpcStatusR = milvusClient.loadCollection(loadCollectionParam);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/ReleaseCollectionTest.java

@@ -0,0 +1,37 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("ReleaseCollection")
+public class ReleaseCollectionTest extends BaseTest {
+  @BeforeClass(description = "load collection")
+  public void loadCollection() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "release collection")
+  public void releaseCollectionTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.releaseCollection(
+            ReleaseCollectionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/collection/ShowCollectionsTest.java

@@ -0,0 +1,34 @@
+package com.zilliz.milvustest.collection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.ShowCollectionsResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.ShowCollectionsParam;
+import io.milvus.response.ShowCollResponseWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@Epic("Collection")
+@Feature("ShowCollection")
+public class ShowCollectionsTest extends BaseTest {
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Show collections list")
+  public void showCollectionTest1() {
+    R<ShowCollectionsResponse> respShowCollections =
+        milvusClient.showCollections(ShowCollectionsParam.newBuilder().build());
+    Assert.assertEquals(respShowCollections.getStatus().intValue(), 0);
+    ShowCollResponseWrapper showCollResponseWrapper =
+        new ShowCollResponseWrapper(respShowCollections.getData());
+    System.out.println(showCollResponseWrapper);
+    Assert.assertTrue(showCollResponseWrapper.getCollectionsInfo().size() >= 1);
+    Assert.assertEquals(
+        showCollResponseWrapper.getCollectionInfoByName(CommonData.defaultCollection).getName(),
+        CommonData.defaultCollection);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/compaction/GetCompactionStateTest.java

@@ -0,0 +1,43 @@
+package com.zilliz.milvustest.compaction;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.CompactionState;
+import io.milvus.grpc.GetCompactionStateResponse;
+import io.milvus.grpc.ManualCompactionResponse;
+import io.milvus.param.R;
+import io.milvus.param.control.GetCompactionStateParam;
+import io.milvus.param.control.ManualCompactParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Epic("Compaction")
+@Feature("GetCompactionState")
+public class GetCompactionStateTest extends BaseTest {
+  @DataProvider(name = "provideCompaction")
+  public Object[][] provideManualCompaction() {
+    R<ManualCompactionResponse> responseR =
+        milvusClient.manualCompact(
+            ManualCompactParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    long CompactionId = responseR.getData().getCompactionID();
+    return new Object[][] {{CompactionId}};
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Gets the compaction state by id.", dataProvider = "provideCompaction")
+  public void getCompactionStateTest(long compactionId) {
+    R<GetCompactionStateResponse> responseR =
+        milvusClient.getCompactionState(
+            GetCompactionStateParam.newBuilder().withCompactionID(compactionId).build());
+    Assert.assertEquals(responseR.getStatus().intValue(), 0);
+    GetCompactionStateResponse data = responseR.getData();
+    Assert.assertEquals(data.getState(), CompactionState.Completed);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/compaction/GetCompactionStateWithPlansTest.java

@@ -0,0 +1,42 @@
+package com.zilliz.milvustest.compaction;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.CompactionState;
+import io.milvus.grpc.GetCompactionPlansResponse;
+import io.milvus.grpc.ManualCompactionResponse;
+import io.milvus.param.R;
+import io.milvus.param.control.GetCompactionPlansParam;
+import io.milvus.param.control.ManualCompactParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Epic("Compaction")
+@Feature("GetCompactionStateWithPlans")
+public class GetCompactionStateWithPlansTest extends BaseTest {
+  @DataProvider(name = "provideCompaction")
+  public Object[][] provideManualCompaction() {
+    R<ManualCompactionResponse> responseR =
+        milvusClient.manualCompact(
+            ManualCompactParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    long CompactionId = responseR.getData().getCompactionID();
+    return new Object[][] {{CompactionId}};
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Gets compaction state with its plan.", dataProvider = "provideCompaction")
+  public void getCompactionStateWithPlansTest(long compactionId) {
+    R<GetCompactionPlansResponse> responseR =
+        milvusClient.getCompactionStateWithPlans(
+            GetCompactionPlansParam.newBuilder().withCompactionID(compactionId).build());
+    Assert.assertEquals(responseR.getStatus().intValue(), 0);
+    Assert.assertEquals(responseR.getData().getState(), CompactionState.Completed);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/compaction/ManualCompactionTest.java

@@ -0,0 +1,77 @@
+package com.zilliz.milvustest.compaction;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.grpc.CompactionState;
+import io.milvus.grpc.GetCompactionPlansResponse;
+import io.milvus.grpc.GetCompactionStateResponse;
+import io.milvus.grpc.ManualCompactionResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.FlushParam;
+import io.milvus.param.control.GetCompactionPlansParam;
+import io.milvus.param.control.GetCompactionStateParam;
+import io.milvus.param.control.ManualCompactParam;
+import io.milvus.param.dml.InsertParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Compaction")
+@Feature("ManualCompaction")
+public class ManualCompactionTest extends BaseTest {
+  public String collection;
+
+  @BeforeClass
+  public void providerData() {
+    collection = CommonFunction.createNewCollection();
+    List<InsertParam.Field> fields = CommonFunction.generateData(10000);
+    milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(collection).withFields(fields).build());
+    milvusClient.flush(
+        FlushParam.newBuilder().withCollectionNames(Arrays.asList(collection)).build());
+    List<InsertParam.Field> fields2 = CommonFunction.generateData(20000);
+    milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(collection).withFields(fields2).build());
+    milvusClient.flush(
+        FlushParam.newBuilder().withCollectionNames(Arrays.asList(collection)).build());
+  }
+
+  @AfterClass
+  public void dropCollection() {
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "performs a manual compaction.")
+  public void manualCompactionTest() {
+    R<ManualCompactionResponse> responseR =
+        milvusClient.manualCompact(
+            ManualCompactParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    Assert.assertEquals(responseR.getStatus().intValue(), 0);
+    Assert.assertTrue(responseR.getData().getCompactionID() > 0);
+    long compactionID = responseR.getData().getCompactionID();
+    R<GetCompactionStateResponse> GetCompactionStateResponse =
+            milvusClient.getCompactionState(
+                    GetCompactionStateParam.newBuilder().withCompactionID(compactionID).build());
+    Assert.assertEquals(GetCompactionStateResponse.getStatus().intValue(), 0);
+    Assert.assertEquals(GetCompactionStateResponse.getData().getState(), CompactionState.Completed);
+    R<GetCompactionPlansResponse> GetCompactionPlansResponse =
+            milvusClient.getCompactionStateWithPlans(
+                    GetCompactionPlansParam.newBuilder().withCompactionID(compactionID).build());
+    Assert.assertEquals(GetCompactionPlansResponse.getStatus().intValue(), 0);
+    Assert.assertEquals(GetCompactionPlansResponse.getData().getState(),CompactionState.Completed);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/connection/CloseTest.java

@@ -0,0 +1,18 @@
+package com.zilliz.milvustest.connection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.annotations.Test;
+
+/**
+ * @Author yongpeng.li
+ * @Date 2022/7/11 14:14
+ */
+public class CloseTest extends BaseTest {
+    @Test(description = "close connection",enabled = false)
+    @Severity(SeverityLevel.BLOCKER)
+    public void closeConnection(){
+        milvusClient.close();
+    }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/connection/ConnectionTest.java

@@ -0,0 +1,31 @@
+package com.zilliz.milvustest.connection;
+
+import com.zilliz.milvustest.common.BaseTest;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.param.ConnectParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+@Epic("Connection")
+@Feature("Connect")
+public class ConnectionTest extends BaseTest {
+
+  @DataProvider(name = "connectParm")
+  public Object[][] getHostAndProt() {
+    return new Object[][] {
+      {"in01-4fb62d5b6d1f782.aws-ap-southeast-1.vectordb-sit.zillizcloud.com", 19530}
+    };
+  }
+
+  @Test(dataProvider = "connectParm")
+  @Severity(SeverityLevel.BLOCKER)
+  public void connectMilvus(String host, Integer prot) {
+    MilvusServiceClient milvusClient =
+        new MilvusServiceClient(ConnectParam.newBuilder().withHost(host).withPort(prot).build());
+    System.out.println(milvusClient);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/credential/CreateCredentialTest.java

@@ -0,0 +1,98 @@
+package com.zilliz.milvustest.credential;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.exception.ParamException;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.credential.CreateCredentialParam;
+import io.milvus.param.credential.DeleteCredentialParam;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Credential")
+@Feature("CreateCredential")
+public class CreateCredentialTest extends BaseTest {
+  private String username;
+  private String password;
+
+  @BeforeClass
+  public void initCredentialInfo() {
+    username = "user_" + MathUtil.getRandomString(5);
+    password = "Pawd_" + MathUtil.getRandomString(5);
+  }
+
+  @AfterClass
+  public void deleteCredentialInfo() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.deleteCredential(
+            DeleteCredentialParam.newBuilder().withUsername(username).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Create credential using the given user and password.")
+  public void createCredentialTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createCredential(
+            CreateCredentialParam.newBuilder()
+                .withUsername(username)
+                .withPassword(password)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "Create credential use repeated username",
+      dependsOnMethods = "createCredentialTest")
+  public void createCredentialRepeatedly() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createCredential(
+            CreateCredentialParam.newBuilder()
+                .withUsername("root")
+                .withPassword("Root123")
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), -3);
+    Assert.assertEquals(rpcStatusR.getException().getMessage(), "user already exists:root");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Check the rule of password ")
+  public void checkTheRuleOfPassword() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createCredential(
+            CreateCredentialParam.newBuilder()
+                .withUsername(CommonData.defaultUserName)
+                .withPassword("r")
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 5);
+    Assert.assertEquals(
+        rpcStatusR.getException().getMessage(),
+        "The length of password must be great than 6 and less than 256 characters.");
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(
+      description = "Create credential without username",
+      expectedExceptions = ParamException.class)
+  public void createCredentialWithoutUsername() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createCredential(
+            CreateCredentialParam.newBuilder().withPassword(CommonData.defaultPassword).build());
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(
+      description = "Create credential without password",
+      expectedExceptions = ParamException.class)
+  public void createCredentialWithoutPassword() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createCredential(
+            CreateCredentialParam.newBuilder().withUsername(CommonData.defaultUserName).build());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/credential/DeleteCredentialTest.java

@@ -0,0 +1,72 @@
+package com.zilliz.milvustest.credential;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.credential.CreateCredentialParam;
+import io.milvus.param.credential.DeleteCredentialParam;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Credential")
+@Feature("DeleteCredential")
+public class DeleteCredentialTest extends BaseTest {
+  private String username;
+  private String password;
+
+  @BeforeClass
+  public void initCredentialInfo() {
+    username = "user_" + MathUtil.getRandomString(5);
+    password = "Pawd_" + MathUtil.getRandomString(5);
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createCredential(
+            CreateCredentialParam.newBuilder()
+                .withUsername(username)
+                .withPassword(password)
+                .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "delete credential by username")
+  public void deleteCredential() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.deleteCredential(
+            DeleteCredentialParam.newBuilder().withUsername(username).build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "delete credential repeatedly", dependsOnMethods = "deleteCredential")
+  public void deleteCredentialRepeatedly() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.deleteCredential(
+            DeleteCredentialParam.newBuilder().withUsername(username).build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "delete root credential ")
+  public void deleteRootCredential() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.deleteCredential(
+            DeleteCredentialParam.newBuilder().withUsername("root").build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), -3);
+    Assert.assertEquals(rpcStatusR.getException().getMessage(), "user root cannot be deleted");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "delete credential nonexistent username")
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/308")
+  public void deleteCredentialNonexistent() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.deleteCredential(
+            DeleteCredentialParam.newBuilder().withUsername("nonexistent").build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/credential/ListCredUsersTest.java

@@ -0,0 +1,29 @@
+package com.zilliz.milvustest.credential;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.ListCredUsersResponse;
+import io.milvus.param.R;
+import io.milvus.param.credential.ListCredUsersParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@Epic("Credential")
+@Feature("ListCredUser")
+public class ListCredUsersTest extends BaseTest {
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "List all user names")
+  public void listCredUsersTest() {
+    R<ListCredUsersResponse> listCredUsersResponseR =
+        milvusClient.listCredUsers(ListCredUsersParam.newBuilder().build());
+    Assert.assertEquals(listCredUsersResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(listCredUsersResponseR.getData().getUsernamesList().size() > 1);
+    Assert.assertTrue(
+        listCredUsersResponseR.getData().getUsernamesList().contains(CommonData.defaultUserName));
+    System.out.println(listCredUsersResponseR.getData());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/credential/UpdateCredentialTest.java

@@ -0,0 +1,81 @@
+package com.zilliz.milvustest.credential;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.credential.CreateCredentialParam;
+import io.milvus.param.credential.DeleteCredentialParam;
+import io.milvus.param.credential.UpdateCredentialParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Credential")
+@Feature("UpdateCredential")
+public class UpdateCredentialTest extends BaseTest {
+  private String username;
+  private String password;
+
+  @BeforeClass
+  public void initCredentialInfo() {
+    username = "user_" + MathUtil.getRandomString(5);
+    password = "Pwd_" + MathUtil.getRandomString(5);
+    milvusClient.createCredential(
+        CreateCredentialParam.newBuilder().withUsername(username).withPassword(password).build());
+  }
+
+  @AfterClass
+  public void deleteCredentialInfo() {
+    milvusClient.deleteCredential(
+        DeleteCredentialParam.newBuilder().withUsername(username).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Update credential using the given user and password")
+  public void updateCredentialTest() {
+    String newPWD = "Pwd_" + MathUtil.getRandomString(6);
+    R<RpcStatus> rpcStatusR =
+        milvusClient.updateCredential(
+            UpdateCredentialParam.newBuilder()
+                .withUsername(username)
+                .withOldPassword(password)
+                .withNewPassword(newPWD)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Update root  credential")
+  public void updateRootCredentialTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.updateCredential(
+            UpdateCredentialParam.newBuilder()
+                .withUsername("root")
+                .withOldPassword("Milvus")
+                .withNewPassword("Milvus")
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Update credential with nonexistent username")
+  public void updateCredentialNonexistentUserName() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.updateCredential(
+            UpdateCredentialParam.newBuilder()
+                .withUsername("nonexistent")
+                .withOldPassword("nonexistent")
+                .withNewPassword("nonexistent")
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), -3);
+    Assert.assertEquals(rpcStatusR.getException().getMessage(), "found no credential:nonexistent");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/flush/FlushTest.java

@@ -0,0 +1,61 @@
+package com.zilliz.milvustest.flush;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.FlushResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.FlushParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Epic("Flush")
+@Feature("Flush")
+public class FlushTest extends BaseTest {
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "flush collection sync ", enabled = true)
+  public void flushCollectionSync() {
+    List<String> collectionName =
+        new ArrayList<String>() {
+          {
+            add(CommonData.defaultCollection);
+          }
+        };
+    R<FlushResponse> flushResponseR =
+        milvusClient.flush(
+            FlushParam.newBuilder()
+                .withCollectionNames(collectionName)
+                .withSyncFlush(Boolean.TRUE)
+                .build());
+    Assert.assertEquals(flushResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(flushResponseR.getData().containsCollSegIDs(CommonData.defaultCollection));
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "flush collection async", enabled = true)
+  public void flushCollectionAsync() {
+    List<String> collectionName =
+        new ArrayList<String>() {
+          {
+            add(CommonData.defaultCollection);
+          }
+        };
+    R<FlushResponse> flushResponseR =
+        milvusClient.flush(
+            FlushParam.newBuilder()
+                .withCollectionNames(collectionName)
+                .withSyncFlushWaitingTimeout(30L)
+                .withSyncFlushWaitingInterval(500L)
+                .withSyncFlush(Boolean.FALSE)
+                .build());
+    Assert.assertEquals(flushResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(flushResponseR.getData().containsCollSegIDs(CommonData.defaultCollection));
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/flush/GetFlushStateTest.java

@@ -0,0 +1,78 @@
+package com.zilliz.milvustest.flush;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.FlushResponse;
+import io.milvus.grpc.GetFlushStateResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.FlushParam;
+import io.milvus.param.control.GetFlushStateParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Epic("Flush")
+@Feature("GetFlushState")
+public class GetFlushStateTest extends BaseTest {
+  @DataProvider(name = "providerSegmentIds")
+  public Object[][] providerSegmentId() {
+    List<String> collections =
+        new ArrayList<String>() {
+          {
+            add(CommonData.defaultCollection);
+            add(CommonData.defaultBinaryCollection);
+            add(CommonData.defaultStringPKCollection);
+          }
+        };
+    R<FlushResponse> flushResponseR =
+        milvusClient.flush(FlushParam.newBuilder().withCollectionNames(collections).build());
+    Map<Long, String> maps = new HashMap<>();
+    collections.forEach(
+        x -> {
+          List<Long> dataList = flushResponseR.getData().getCollSegIDsOrThrow(x).getDataList();
+          dataList.forEach(
+              y -> {
+                maps.put(y, x);
+              });
+        });
+    int i = 0;
+    Object[][] objects = new Object[maps.size()][2];
+    for (Long key : maps.keySet()) {
+      objects[i][0] = key;
+      objects[i][1] = maps.get(key);
+      i++;
+    }
+    return objects;
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Get flush state of specified segments.", dataProvider = "providerSegmentIds")
+  public void getFlushStateTest(Long segmentId, String collection) {
+    R<GetFlushStateResponse> getFlushStateResponseR =
+        milvusClient.getFlushState(GetFlushStateParam.newBuilder().addSegmentID(segmentId).build());
+    Assert.assertEquals(getFlushStateResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(getFlushStateResponseR.getData().getFlushed());
+    System.out.println("Collection-" + collection + ":" + getFlushStateResponseR.getData());
+  }
+
+    @Severity(SeverityLevel.MINOR)
+    @Test(description = "Get flush state with nonexistent segmentId",expectedExceptions = ParamException.class)
+    public void getFlushStateWithoutSegmentId() {
+        R<GetFlushStateResponse> getFlushStateResponseR =
+                milvusClient.getFlushState(GetFlushStateParam.newBuilder().build());
+        Assert.assertEquals(getFlushStateResponseR.getStatus().intValue(), 1);
+        Assert.assertEquals(getFlushStateResponseR.getException().getMessage(),"Segment id array cannot be empty");
+
+    }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/index/CreateIndexTest.java

@@ -0,0 +1,197 @@
+package com.zilliz.milvustest.index;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.index.DropIndexParam;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import static com.zilliz.milvustest.util.MathUtil.combine;
+
+@Epic("Index")
+@Feature("CreateIndex")
+public class CreateIndexTest extends BaseTest {
+  public String collection;
+  public String binaryCollection;
+
+  @BeforeClass(description = "create collection for test")
+  public void createCollection() {
+    collection = CommonFunction.createNewCollection();
+    binaryCollection = CommonFunction.createBinaryCollection();
+  }
+
+  @AfterClass(description = "drop collection after test")
+  public void dropCollection() {
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collection).build());
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(binaryCollection).build());
+  }
+
+  @DataProvider(name = "IndexTypes")
+  public Object[][] provideIndexType() {
+    return new Object[][] {
+      {IndexType.FLAT},
+      {IndexType.IVF_FLAT},
+      {IndexType.IVF_SQ8},
+      {IndexType.IVF_PQ},
+      {IndexType.HNSW},
+      {IndexType.ANNOY},
+      {IndexType.RHNSW_FLAT},
+      {IndexType.RHNSW_PQ},
+      {IndexType.RHNSW_SQ}
+    };
+  }
+
+  @DataProvider(name = "BinaryIndexTypes")
+  public Object[][] provideBinaryIndexType() {
+    return new Object[][] {{IndexType.BIN_IVF_FLAT}, {IndexType.BIN_FLAT}};
+  }
+
+  @DataProvider(name = "MetricType")
+  public Object[][] providerMetricType() {
+    return new Object[][] {{MetricType.L2}, {MetricType.IP}};
+  }
+
+  @DataProvider(name = "BinaryMetricType")
+  public Object[][] providerBinaryMetricType() {
+    return new Object[][] {
+      {MetricType.HAMMING},
+      {MetricType.JACCARD},
+      {MetricType.SUBSTRUCTURE},
+      {MetricType.SUPERSTRUCTURE},
+      {MetricType.TANIMOTO}
+    };
+  }
+
+  @DataProvider(name = "FloatIndex")
+  public Object[][] providerIndexForFloatCollection() {
+    return combine(provideIndexType(), providerMetricType());
+  }
+
+  @DataProvider(name = "BinaryIndex")
+  public Object[][] providerIndexForBinaryCollection() {
+    return combine(provideBinaryIndexType(), providerBinaryMetricType());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/311")
+  @Test(description = "Create index for collection sync", dataProvider = "FloatIndex")
+  public void createIndexSync(IndexType indexType, MetricType metricType) {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                .withSyncMode(Boolean.TRUE)
+                .withSyncWaitingTimeout(30L)
+                .withSyncWaitingInterval(500L)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultIndex)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/311")
+  @Test(description = "Create index for collection Async", dataProvider = "FloatIndex")
+  public void createIndexAsync(IndexType indexType, MetricType metricType) {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                    .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultIndex)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/321")
+  @Test(description = "Create index for collection Async", dataProvider = "BinaryIndex")
+  public void createBinaryIndexAsync(IndexType indexType, MetricType metricType) {
+    if(indexType.equals(IndexType.BIN_IVF_FLAT)&&(metricType.equals(MetricType.SUBSTRUCTURE)||metricType.equals(MetricType.SUPERSTRUCTURE))){
+      return;
+    }
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(binaryCollection)
+                .withFieldName(CommonData.defaultBinaryVectorField)
+                .withIndexName(CommonData.defaultBinaryIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonData.defaultExtraParam)
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(binaryCollection)
+            .withIndexName(CommonData.defaultBinaryIndex)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/321")
+  @Test(description = "Create index for collection sync", dataProvider = "BinaryIndex")
+  public void createBinaryIndexSync(IndexType indexType, MetricType metricType) {
+    if(indexType.equals(IndexType.BIN_IVF_FLAT)&&(metricType.equals(MetricType.SUBSTRUCTURE)||metricType.equals(MetricType.SUPERSTRUCTURE))){
+      return;
+    }
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(binaryCollection)
+                .withFieldName(CommonData.defaultBinaryVectorField)
+                .withIndexName(CommonData.defaultBinaryIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonData.defaultExtraParam)
+                .withSyncMode(Boolean.TRUE)
+                .withSyncWaitingTimeout(30L)
+                .withSyncWaitingInterval(500L)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(binaryCollection)
+            .withIndexName(CommonData.defaultBinaryIndex)
+            .build());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/index/DescribeIndexTest.java

@@ -0,0 +1,89 @@
+package com.zilliz.milvustest.index;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.DescribeIndexResponse;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.index.DescribeIndexParam;
+import io.milvus.param.index.DropIndexParam;
+import io.milvus.response.DescIndexResponseWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Index")
+@Feature("DescribeIndex")
+public class DescribeIndexTest extends BaseTest {
+  public String collection;
+
+  @BeforeClass(description = "Create collection and index for test")
+  public void createCollectionAndIndex() {
+    collection = CommonFunction.createNewCollection();
+    milvusClient.createIndex(
+        CreateIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withFieldName(CommonData.defaultVectorField)
+            .withIndexName(CommonData.defaultIndex)
+            .withMetricType(MetricType.L2)
+            .withIndexType(IndexType.IVF_FLAT)
+            .withExtraParam(CommonData.defaultExtraParam)
+            .withSyncMode(Boolean.FALSE)
+            .build());
+  }
+
+  @AfterClass(description = "drop collection after test")
+  public void dropCollection() {
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultVectorField)
+            .build());
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Describe Index")
+  public void describeIndex() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+        milvusClient.describeIndex(
+            DescribeIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withIndexName(CommonData.defaultVectorField)
+                .build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 0);
+    DescIndexResponseWrapper descIndexResponseWrapper =
+        new DescIndexResponseWrapper(describeIndexResponseR.getData());
+    Assert.assertEquals(
+        descIndexResponseWrapper
+            .getIndexDescByFieldName(CommonData.defaultVectorField)
+            .getIndexName(),
+        CommonData.defaultIndex);
+    Assert.assertEquals(
+        descIndexResponseWrapper
+            .getIndexDescByFieldName(CommonData.defaultVectorField)
+            .getFieldName(),
+        CommonData.defaultVectorField);
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(
+      description = "Describe Index without field name",
+      expectedExceptions = ParamException.class)
+  public void describeIndexWithoutField() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+        milvusClient.describeIndex(
+            DescribeIndexParam.newBuilder().withCollectionName(collection).build());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/index/DropIndexTest.java

@@ -0,0 +1,136 @@
+package com.zilliz.milvustest.index;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.DescribeIndexResponse;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.index.DescribeIndexParam;
+import io.milvus.param.index.DropIndexParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Index")
+@Feature("DropIndex")
+public class DropIndexTest extends BaseTest {
+  public String collection;
+
+  @BeforeClass(description = "create collection and  index for test")
+  public void createCollectionAndIndex() {
+    collection = CommonFunction.createNewCollection();
+    milvusClient.createIndex(
+        CreateIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withFieldName(CommonData.defaultVectorField)
+            .withIndexName(CommonData.defaultIndex)
+            .withMetricType(MetricType.L2)
+            .withIndexType(IndexType.IVF_FLAT)
+            .withExtraParam(CommonData.defaultExtraParam)
+            .withSyncMode(Boolean.FALSE)
+            .build());
+  }
+
+  @AfterClass(description = "drop collection after test")
+  public void dropCollection() {
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultVectorField)
+            .build());
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "drop index success")
+  public void dropIndexSuccess() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropIndex(
+            DropIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withIndexName(CommonData.defaultVectorField)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "drop index without field name", expectedExceptions = ParamException.class)
+  public void dropIndexWithoutFieldName() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropIndex(DropIndexParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "drop index with error field name")
+  public void dropIndexWithErrorFieldName() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropIndex(
+            DropIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withIndexName("book_id")
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "drop index with nonexistent field name")
+  public void dropIndexWithNonexistentFieldName() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropIndex(
+            DropIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withIndexName("nonexistent")
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        rpcStatusR.getException().getMessage(),
+        "DropIndex failed: collection " + collection + " doesn't have filed nonexistent");
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(
+      description = "describe index after drop index",
+      dependsOnMethods = "dropIndexSuccess",
+      enabled = false)
+  public void describeIndexAfterDropIndex() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+        milvusClient.describeIndex(
+            DescribeIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withIndexName(CommonData.defaultVectorField)
+                .build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 0);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "create index after drop index", dependsOnMethods = "dropIndexSuccess")
+  public void createIndexAfterDrop(){
+    R<RpcStatus> indexR = milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(collection)
+                    .withFieldName(CommonData.defaultVectorField)
+                    .withIndexName(CommonData.defaultIndex)
+                    .withMetricType(MetricType.IP)
+                    .withIndexType(IndexType.IVF_FLAT)
+                    .withExtraParam(CommonData.defaultExtraParam)
+                    .withSyncMode(Boolean.FALSE)
+                    .build());
+    Assert.assertEquals(indexR.getStatus().intValue(),0);
+    Assert.assertEquals(indexR.getData().getMsg(),"Success");
+
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/index/GetIndexBuildProgressTest.java

@@ -0,0 +1,78 @@
+package com.zilliz.milvustest.index;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.grpc.DescribeIndexResponse;
+import io.milvus.grpc.GetIndexBuildProgressResponse;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.index.DescribeIndexParam;
+import io.milvus.param.index.DropIndexParam;
+import io.milvus.param.index.GetIndexBuildProgressParam;
+import io.milvus.response.DescIndexResponseWrapper;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Index")
+@Feature("GetIndexBuildProgress")
+public class GetIndexBuildProgressTest extends BaseTest {
+  public String collection;
+
+  @BeforeClass(description = "Create collection and index for test")
+  public void createCollectionAndIndex() {
+    collection = CommonFunction.createNewCollection();
+    milvusClient.createIndex(
+        CreateIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withFieldName(CommonData.defaultVectorField)
+            .withIndexName(CommonData.defaultIndex)
+            .withMetricType(MetricType.L2)
+            .withIndexType(IndexType.IVF_FLAT)
+            .withExtraParam(CommonData.defaultExtraParam)
+            .withSyncMode(Boolean.TRUE)
+                .withSyncWaitingInterval(500L)
+                .withSyncWaitingTimeout(30L)
+            .build());
+  }
+
+  @AfterClass(description = "drop collection after test")
+  public void dropCollection() {
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultVectorField)
+            .build());
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Get Index Build Progress")
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/299")
+  public void getIndexBuildProgressTest() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+        milvusClient.describeIndex(
+            DescribeIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withIndexName(CommonData.defaultVectorField)
+                .build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 0);
+    DescribeIndexResponse describeIndexResponse = describeIndexResponseR.getData();
+    DescIndexResponseWrapper descIndexResponseWrapper =
+        new DescIndexResponseWrapper(describeIndexResponse);
+    System.out.println(descIndexResponseWrapper);
+
+    R<GetIndexBuildProgressResponse> indexBuildProgress =
+        milvusClient.getIndexBuildProgress(
+            GetIndexBuildProgressParam.newBuilder().withCollectionName(collection).build());
+    Assert.assertEquals(indexBuildProgress.getStatus().intValue(), 0);
+    Assert.assertEquals(indexBuildProgress.getData().getIndexedRows(), 0);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/index/GetIndexStateTest.java

@@ -0,0 +1,67 @@
+package com.zilliz.milvustest.index;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.grpc.GetIndexStateResponse;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.param.index.DropIndexParam;
+import io.milvus.param.index.GetIndexStateParam;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Index")
+@Feature("GetIndexState")
+public class GetIndexStateTest extends BaseTest {
+  public String collection;
+
+  @BeforeClass(description = "Create collection and index for test")
+  public void createCollectionAndIndex() {
+    collection = CommonFunction.createNewCollection();
+    R<RpcStatus> indexR = milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(collection)
+                    .withFieldName(CommonData.defaultVectorField)
+                    .withIndexName(CommonData.defaultIndex)
+                    .withMetricType(MetricType.L2)
+                    .withIndexType(IndexType.IVF_FLAT)
+                    .withExtraParam(CommonData.defaultExtraParam)
+                    .withSyncMode(Boolean.FALSE)
+                    .build());
+    softAssert.assertEquals(indexR.getStatus().intValue(),0);
+    softAssert.assertAll();
+  }
+
+  @AfterClass(description = "drop collection after test")
+  public void dropCollection() {
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultVectorField)
+            .build());
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Get index state of default collection")
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/302")
+  public void getIndexStateDefault() {
+    R<GetIndexStateResponse> getIndexStateResponseR =
+        milvusClient.getIndexState(
+            GetIndexStateParam.newBuilder()
+                .withCollectionName(collection)
+                .withIndexName(CommonData.defaultVectorField)
+                .build());
+    Assert.assertEquals(getIndexStateResponseR.getStatus().intValue(), 0);
+    Assert.assertEquals(getIndexStateResponseR.getData(), 0);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/insert/DeleteTest.java

@@ -0,0 +1,90 @@
+package com.zilliz.milvustest.insert;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.R;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+@Epic("Index")
+@Feature("Delete")
+public class DeleteTest extends BaseTest {
+  public String commonCollection;
+  public String commonPartition;
+
+  @BeforeClass(description = "Create collection before test")
+  public void provideCollectionName() {
+    commonCollection = CommonFunction.createNewCollection();
+    commonPartition = "partition_" + MathUtil.getRandomString(10);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(commonCollection)
+            .withPartitionName(commonPartition)
+            .build());
+    List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+    milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(commonCollection).withPartitionName(commonPartition).withFields(fields).build());
+  }
+
+  @AfterClass(description = "delete collection after deleteDataTest")
+  public void deleteTestData() {
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(commonCollection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "delete data in expression ")
+  public void deleteData() {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(commonCollection)
+                .withExpr("book_id in [1,2,3]")
+                .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "delete data in expression by partition ")
+  public void deleteDataByPartition() {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(commonCollection)
+                .withPartitionName(commonPartition)
+                .withExpr("book_id in [1,2,3]")
+                .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "delete data with invalid expression ")
+  public void deleteDataInvalidExpression() {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(commonCollection)
+                .withExpr("book_id not in  [1,2,3]")
+                .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        mutationResultR.getException().getMessage(),
+        "invalid plan node type, only pk in [1, 2] supported");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/insert/InsertAsyncTest.java

@@ -0,0 +1,39 @@
+package com.zilliz.milvustest.insert;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.R;
+import io.milvus.param.dml.InsertParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+@Epic("Index")
+@Feature("InsertAsyncT")
+public class InsertAsyncTest extends BaseTest {
+
+  @Test(description = "Insert data Async")
+  @Severity(SeverityLevel.BLOCKER)
+  public void insertAsyncSuccess() throws ExecutionException, InterruptedException {
+    List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+        milvusClient.insertAsync(
+            InsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFields(fields)
+                .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 2000);
+    System.out.println(mutationResultR.getData());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/insert/InsertTest.java

@@ -0,0 +1,96 @@
+package com.zilliz.milvustest.insert;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.R;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.dml.InsertParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+@Epic("Index")
+@Feature("Insert")
+public class InsertTest extends BaseTest {
+  public String stringPKAndBinaryCollection;
+
+  @BeforeClass(description = "provider collection")
+  public void providerData() {
+    stringPKAndBinaryCollection = CommonFunction.createStringPKAndBinaryCollection();
+  }
+
+  @AfterClass(description = "delete test data")
+  public void deleteData() {
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(stringPKAndBinaryCollection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Insert data into collection")
+  public void insertDataIntoCollection() {
+    List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+    R<MutationResult> mutationResultR =
+        milvusClient.insert(
+            InsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFields(fields)
+                .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 2000);
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 0);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Insert data into partition")
+  public void insertDataIntoPartition() {
+    List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+    R<MutationResult> mutationResultR =
+        milvusClient.insert(
+            InsertParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(CommonData.defaultPartition)
+                .withFields(fields)
+                .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 2000);
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 0);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Multiple insert into String pk and binary vector Collection")
+  public void multipleInsertIntoStringPKAndBinaryCollection() {
+    List<InsertParam.Field> fields = CommonFunction.generateStringPKBinaryData(2000);
+    R<MutationResult> mutationResultR =
+        milvusClient.insert(
+            InsertParam.newBuilder()
+                .withCollectionName(stringPKAndBinaryCollection)
+                .withFields(fields)
+                .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 2000);
+
+    List<InsertParam.Field> fields2 = CommonFunction.generateStringPKBinaryData(3000);
+    R<MutationResult> mutationResultR2 =
+        milvusClient.insert(
+            InsertParam.newBuilder()
+                .withCollectionName(stringPKAndBinaryCollection)
+                .withFields(fields2)
+                .build());
+    Assert.assertEquals(mutationResultR2.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR2.getData().getSuccIndexCount(), 3000);
+
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/load/BulkLoadTest.java

@@ -0,0 +1,174 @@
+/*
+package com.zilliz.milvustest.load;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.entity.FieldType;
+import com.zilliz.milvustest.entity.FileBody;
+import com.zilliz.milvustest.util.FileUtils;
+import com.zilliz.milvustest.util.JacksonUtil;
+import com.zilliz.milvustest.util.MathUtil;
+import com.zilliz.milvustest.util.PropertyFilesUtil;
+import io.milvus.grpc.ImportResponse;
+import io.milvus.param.R;
+import io.milvus.param.dml.BulkloadParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Story;
+import lombok.NonNull;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.io.IOException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class BulkLoadTest extends BaseTest {
+    public int fileNums = 10;
+
+    @BeforeClass(description = "initial test json files")
+    public void generateJsonFiles() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
+        List<FileBody> fileBodyList = CommonFunction.generateDefaultFileBody();
+        String path = CommonData.defaultBulkLoadPath;
+
+        FileUtils.generateMultipleFiles(Boolean.TRUE, 10, 128, fileBodyList, true
+                , path, CommonData.defaultRowJson, "json", fileNums);
+        FileUtils.generateMultipleFiles(Boolean.FALSE, 10, 128, fileBodyList, true
+                , path, CommonData.defaultColJson, "json", fileNums);
+        FileUtils.generateMultipleFiles(Boolean.TRUE, 0, 128, fileBodyList, true
+                , path, "empty", "json", 1);
+
+        List<FileBody> stringFileBody = CommonFunction.generateDefaultStringFileBody();
+        FileUtils.generateMultipleFiles(Boolean.TRUE, 10, 128, stringFileBody, null
+                , path, CommonData.defaultRowStrJson, "json", fileNums);
+        FileUtils.generateMultipleFiles(Boolean.FALSE, 10, 128, stringFileBody, null
+                , path, CommonData.defaultColStrJson, "json", 10);
+        List<String> filenames = new ArrayList<>();
+        for (int i = 0; i < fileNums; i++) {
+            filenames.add(CommonData.defaultRowJson + i + ".json");
+            filenames.add(CommonData.defaultColJson + i + ".json");
+            filenames.add(CommonData.defaultRowStrJson + i + ".json");
+            filenames.add(CommonData.defaultColStrJson + i + ".json");
+        }
+        filenames.add("empty0.json");
+
+        FileUtils.multiFilesUpload(path, filenames, null);
+
+    }
+
+    @Epic("L0")
+    @Test(description = "Import single row based json")
+    public void loadSingleRowJsonTest() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection).withRowBased(true)
+                .addFile("rowJson0.json")
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+    }
+
+    @Epic("L0")
+    @Test(description = "Import single column based json")
+    public void loadSingleColJsonTest() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("colJson0.json").withRowBased(false)
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+    }
+
+    @Epic("L0")
+    @Test(description = "Import multiple row based json")
+    public void loadMultipleRowJsonTest() {
+        List<String> fileNames = new ArrayList<>();
+        for (int i = 0; i < fileNums; i++) {
+            fileNames.add(CommonData.defaultRowJson + i + ".json");
+        }
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFiles(fileNames)
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), fileNums);
+    }
+
+    @Epic("L0")
+    @Test(description = "Import multiple column based json")
+    public void loadMultipleColJsonTest() {
+        List<String> fileNames = new ArrayList<>();
+        for (int i = 0; i < fileNums; i++) {
+            fileNames.add(CommonData.defaultColJson + i + ".json");
+        }
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFiles(fileNames)
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), fileNums);
+    }
+
+    @Feature("L1")
+    @Test(description = "Import  row and column based json with add method")
+    public void loadMixedJsonTest() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile(CommonData.defaultRowJson + 0 + ".json")
+                .addFile(CommonData.defaultColJson + 0 + ".json")
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), 2);
+    }
+
+    @Story("L2")
+    @Test(description = "Import  empty row json")
+    public void loadEmptyJsonTest() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("empty0.json")
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+    }
+
+    @Story("L2")
+    @Test(description = "Import  nonexistent  json")
+    public void loadNonexistentJsonTest() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("nonexistent.json")
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+    }
+
+    @Epic("L0")
+    @Test(description = "Import single row-based json into String type field")
+    public void loadSingleRowJsonIntoStringCollection() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultStringCollection)
+                .addFile("rowStrJson0.json")
+                .withRowBased(true)
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+    }
+
+    @Epic("L0")
+    @Test(description = "Import single col-based json into String type field")
+    public void loadSingleColJsonIntoStringCollection() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("colStrJson0.json")
+                .withRowBased(false)
+                .build());
+        Assert.assertEquals(importResponseR.getStatus().intValue(), 0);
+        Assert.assertEquals(importResponseR.getData().getTasksCount(), 1);
+    }
+}
+*/

tests/milvustest/src/test/java/com/zilliz/milvustest/load/GetBulkloadStateTest.java

@@ -0,0 +1,161 @@
+/*
+package com.zilliz.milvustest.load;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.entity.FileBody;
+import com.zilliz.milvustest.util.FileUtils;
+import io.milvus.grpc.GetImportStateResponse;
+import io.milvus.grpc.ImportResponse;
+import io.milvus.grpc.ListImportTasksResponse;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.BulkloadParam;
+import io.milvus.param.dml.GetBulkloadStateParam;
+import io.milvus.param.dml.ListBulkloadTasksParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Issue;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.io.IOException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class GetBulkloadStateTest extends BaseTest {
+    @DataProvider(name = "singleRowBasedTaskId")
+    public Object[][] singleRowBasedBulkLoad(){
+        Object[][] objects=new Object[1][1];
+        R<ImportResponse> importResponseR=milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("rowJson0.json")
+                .withRowBased(true)
+                .build());
+        ImportResponse data = importResponseR.getData();
+        Optional.ofNullable(data).ifPresent(x-> objects[0][0]=x.getTasks(0));
+        return objects;
+    }
+
+    @DataProvider(name = "singleColBasedTaskId")
+    public Object[][] singleColBasedBulkLoad(){
+        Object[][] objects=new Object[1][1];
+        R<ImportResponse> importResponseR=milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("colJson0.json")
+                .withRowBased(false)
+                .build());
+        ImportResponse data = importResponseR.getData();
+        Optional.ofNullable(data).ifPresent(x-> objects[0][0]=x.getTasks(0));
+        return objects;
+    }
+
+    @DataProvider(name = "bigRowJsomTaskId")
+    public Object[][] bigRowBasedTask() throws IOException, NoSuchAlgorithmException, InvalidKeyException {
+        String path = CommonData.defaultBulkLoadPath;
+        List<FileBody> fileBodyList = CommonFunction.generateDefaultFileBody();
+        Boolean aBoolean = FileUtils.generateMultipleFiles(Boolean.TRUE, 1000, 128, fileBodyList, true
+                , path, "bigJson", "json", 1);
+        System.out.println(aBoolean);
+        FileUtils.fileUploader(path,"bigJson0.json",null);
+        R<ImportResponse> bulkload = milvusClient.bulkload(BulkloadParam.newBuilder().withCollectionName(CommonData.defaultCollection)
+                .addFile("bigJson0.json")
+                .build());
+        ImportResponse data = bulkload.getData();
+        return new Object[][]{{data.getTasksList().get(0)}};
+
+    }
+
+    @Epic("L0")
+    @Test(description = "Get bulk load state of  single row based json task",dataProvider = "singleRowBasedTaskId")
+    public void getSingleRowBaseJsonState(Long taskId){
+        R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                .withTaskID(taskId).build());
+        Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
+        Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
+        try {
+            Thread.sleep(4000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        R<RpcStatus> rpcStatusR = milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+        String query_Param = "book_id in [2,4,6,8]";
+        List<String> outFields= Arrays.asList("book_id","word_count");
+        QueryParam queryParam= QueryParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withOutFields(outFields)
+                .withExpr(query_Param)
+                .build();
+        R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+        QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+        softAssert.assertEquals(queryResultsR.getStatus().intValue(),0);
+        softAssert.assertEquals(queryResultsR.getData().getFieldsDataCount(),2);
+        softAssert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(),4);
+        System.out.println("query book_id:"+wrapperQuery.getFieldWrapper("book_id").getFieldData());
+        System.out.println("query word_count:"+wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    }
+    @Epic("L0")
+    @Test(description = "Get bulk load state of  single column based json task",dataProvider = "singleColBasedTaskId")
+    public void getSingleColBaseJsonState(Long taskId){
+        R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                .withTaskID(taskId).build());
+        System.out.println(bulkloadState);
+        Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
+        Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
+    }
+
+    @Epic("L0")
+    @Test(description = "big row based json bulk load test",dataProvider = "bigRowJsomTaskId")
+    public void getBigRowBasedJsonState(Long taskId){
+        R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                .withTaskID(taskId).build());
+        Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
+        Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
+    }
+
+    @Epic("L0")
+    @Test(description = "get bulk load state of multiple row based json")
+    public void getMultiRowBasedJsonState(){
+        List<String> fileNames = new ArrayList<>();
+        for (int i = 0; i < 10; i++) {
+            fileNames.add(CommonData.defaultRowJson + i + ".json");
+        }
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withFiles(fileNames)
+                .build());
+        List<Long> tasksList = importResponseR.getData().getTasksList();
+        // multiple thread
+        ExecutorService executorService = Executors.newFixedThreadPool(10);
+        for (int i = 0; i < tasksList.size(); i++) {
+            int finalI = i;
+            executorService.execute(new Runnable() {
+                @Override
+                public void run() {
+                    R<GetImportStateResponse> bulkloadState = milvusClient.getBulkloadState(GetBulkloadStateParam.newBuilder()
+                            .withTaskID(tasksList.get(finalI)).build());
+                    System.out.println("execute thread"+finalI);
+                    System.out.println(bulkloadState);
+                    Assert.assertEquals(bulkloadState.getStatus().intValue(),0);
+                    Assert.assertEquals(bulkloadState.getData().getInfosList().size(),1);
+                }
+            });
+        }
+        executorService.shutdown();
+
+
+    }
+
+
+}
+*/

tests/milvustest/src/test/java/com/zilliz/milvustest/load/ListBulkloadTasksTest.java

@@ -0,0 +1,39 @@
+/*
+package com.zilliz.milvustest.load;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.ImportResponse;
+import io.milvus.grpc.ListImportTasksResponse;
+import io.milvus.param.R;
+import io.milvus.param.dml.BulkloadParam;
+import io.milvus.param.dml.ListBulkloadTasksParam;
+import io.qameta.allure.Epic;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.Optional;
+
+public class ListBulkloadTasksTest extends BaseTest {
+    @BeforeClass(description = "init bulk load task")
+    public void bulkLoad() {
+        R<ImportResponse> importResponseR = milvusClient.bulkload(BulkloadParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addFile("rowJson0.json")
+                .addFile("rowJson1.json")
+                .build());
+
+    }
+    @Epic("L0")
+    @Test(description = "List all bulk load tasks")
+    public void listBulkLoadTest() {
+        R<ListImportTasksResponse> listImportTasksResponseR = milvusClient.listBulkloadTasks(ListBulkloadTasksParam.newBuilder()
+                .build());
+        Assert.assertEquals(listImportTasksResponseR.getStatus().intValue(), 0);
+        Assert.assertTrue(listImportTasksResponseR.getData().getTasksList().size()>1);
+    }
+
+}
+*/

tests/milvustest/src/test/java/com/zilliz/milvustest/other/CalcDistanceTest.java

@@ -0,0 +1,45 @@
+package com.zilliz.milvustest.other;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.grpc.CalcDistanceResults;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.dml.CalcDistanceParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Other")
+@Feature("CalcDistance")
+public class CalcDistanceTest extends BaseTest {
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Calculates the distance between the specified vectors.")
+  public void calcDistanceTest() {
+    List<List<Float>> leftList =
+        Arrays.asList(Arrays.asList(0.1f, 0.2f), Arrays.asList(0.2f, 0.8f));
+    List<List<Float>> rightList =
+        Arrays.asList(Arrays.asList(0.3f, 0.4f), Arrays.asList(1.1f, 2.2f));
+    R<CalcDistanceResults> calcDistanceResultsR =
+        milvusClient.calcDistance(
+            CalcDistanceParam.newBuilder()
+                .withMetricType(MetricType.L2)
+                .withVectorsLeft(leftList)
+                .withVectorsRight(rightList)
+                .build());
+    Assert.assertEquals(calcDistanceResultsR.getStatus().intValue(), 0);
+    System.out.println(calcDistanceResultsR.getData());
+    Assert.assertTrue(calcDistanceResultsR.getData().getFloatDist().getData(0) > 0);
+    Assert.assertEquals(calcDistanceResultsR.getData().getFloatDist().getDataCount(), 4);
+  }
+
+
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/other/GetMetricsTest.java

@@ -0,0 +1,43 @@
+package com.zilliz.milvustest.other;
+
+import com.zilliz.milvustest.common.BaseTest;
+import io.milvus.grpc.GetMetricsResponse;
+import io.milvus.param.R;
+import io.milvus.param.control.GetMetricsParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@Epic("Metrics")
+@Feature("GetMetrics")
+public class GetMetricsTest extends BaseTest {
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description =
+          "Gets the runtime metrics information of Milvus, returns the result in .json format.")
+  public void getMetricTest() {
+    String param = "{\"metric_type\": \"system_info\"}";
+    R<GetMetricsResponse> getMetricsResponseR =
+        milvusClient.getMetrics(GetMetricsParam.newBuilder().withRequest(param).build());
+    Assert.assertEquals(getMetricsResponseR.getStatus().intValue(), 0);
+    System.out.println(getMetricsResponseR.getData());
+    Assert.assertTrue(getMetricsResponseR.getData().getResponse().contains("nodes_info"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+          description =
+                  "Gets the runtime metrics information of Milvus, returns the result in .json format.")
+  public void getMetricByNodeInfo() {
+    String param = "{\"metric_type\": \"node_id\"}";
+    R<GetMetricsResponse> getMetricsResponseR =
+            milvusClient.getMetrics(GetMetricsParam.newBuilder().withRequest(param).build());
+    Assert.assertEquals(getMetricsResponseR.getStatus().intValue(), 0);
+    System.out.println(getMetricsResponseR.getData());
+    Assert.assertTrue(getMetricsResponseR.getData().getResponse().contains("nodes_info"));
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/other/GetReplicasTest.java

@@ -0,0 +1,49 @@
+package com.zilliz.milvustest.other;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.GetReplicasResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.control.GetReplicasParam;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Replicas")
+@Feature("GetReplicas")
+public class GetReplicasTest extends BaseTest {
+  @BeforeClass(description = "load collection first")
+  public void loadCollection() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withReplicaNumber(2)
+            .withSyncLoad(Boolean.FALSE)
+            .withSyncLoadWaitingTimeout(30L)
+            .withSyncLoadWaitingInterval(500L)
+            .build());
+  }
+
+  @AfterClass(description = "release collection after test")
+  public void releaseCollection() {
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+  }
+
+  @Test(description = "Returns the collection's replica information")
+  @Severity(SeverityLevel.BLOCKER)
+  public void getReplicasTest() {
+    R<GetReplicasResponse> getReplicasResponseR =
+        milvusClient.getReplicas(
+            GetReplicasParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    Assert.assertEquals(getReplicasResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(getReplicasResponseR.getData().getReplicas(0).getReplicaID() > 0);
+    System.out.println(getReplicasResponseR.getData());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/other/LoadBalanceTest.java

@@ -0,0 +1,64 @@
+package com.zilliz.milvustest.other;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import io.milvus.grpc.GetPersistentSegmentInfoResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.FlushParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.control.GetPersistentSegmentInfoParam;
+import io.milvus.param.control.LoadBalanceParam;
+import io.milvus.param.dml.InsertParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Balance")
+@Feature("LoadBalance")
+public class LoadBalanceTest extends BaseTest {
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Moves segment from a query node to another to keep the load balanced.")
+  public void loadBalanceTest() {
+    // insert
+    List<InsertParam.Field> fields = CommonFunction.generateData(3000);
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withFields(fields)
+            .build());
+    // flush
+    milvusClient.flush(
+        FlushParam.newBuilder()
+            .withCollectionNames(Arrays.asList(CommonData.defaultCollection))
+            .withSyncFlush(true)
+            .withSyncFlushWaitingInterval(500L)
+            .withSyncFlushWaitingTimeout(30L)
+            .build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // query Segment
+    R<GetPersistentSegmentInfoResponse> responseR =
+        milvusClient.getPersistentSegmentInfo(
+            GetPersistentSegmentInfoParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    milvusClient.loadBalance(
+        LoadBalanceParam.newBuilder()
+            .withSegmentIDs(Arrays.asList(434445867837030402L))
+            .withDestinationNodeID(Arrays.asList(6L))
+            .withSourceNodeID(3L)
+            .build());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/partition/CreatePartitionTest.java

@@ -0,0 +1,127 @@
+package com.zilliz.milvustest.partition;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.param.partition.DropPartitionParam;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Partition")
+@Feature("CreatePartition")
+public class CreatePartitionTest extends BaseTest {
+  private String partition;
+
+  @BeforeClass(description = "init partition Name")
+  public void createPartitionTest() {
+    partition = "partition_" + MathUtil.getRandomString(10);
+  }
+
+  @AfterClass(description = "delete partition after test")
+  public void deletePartition() {
+    milvusClient.dropPartition(
+        DropPartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Create partition")
+  public void createPartitionSuccess() {
+    CreatePartitionParam createPartitionParam =
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build();
+    R<RpcStatus> rpcStatusR = milvusClient.createPartition(createPartitionParam);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Test(
+      description = "query float vector from partition ",
+      dependsOnMethods = "createPartitionSuccess")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryFromEmptyPartition() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    List<String> partitions =
+        new ArrayList<String>() {
+          {
+            add(partition);
+          }
+        };
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(partitions)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 26);
+    Assert.assertEquals(queryResultsR.getException().getMessage(), "emptly collection");
+  }
+
+  @Test(
+      description = "query float vector from partition AfterInsertData",
+      dependsOnMethods = {"createPartitionSuccess","queryFromEmptyPartition",})
+  @Severity(SeverityLevel.NORMAL)
+  public void queryFromPartitionAfterInsertData() throws InterruptedException {
+    List<InsertParam.Field> fields = CommonFunction.generateData(100);
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .withFields(fields)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).withSyncLoad(Boolean.TRUE)
+                .withSyncLoadWaitingInterval(1000L).withSyncLoadWaitingTimeout(300L).build());
+    Thread.sleep(5000);
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    List<String> partitions =
+        new ArrayList<String>() {
+          {
+            add(partition);
+          }
+        };
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(partitions)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/partition/DropPartitionTest.java

@@ -0,0 +1,92 @@
+package com.zilliz.milvustest.partition;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.param.partition.DropPartitionParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Partition")
+@Feature("DropPartition")
+public class DropPartitionTest extends BaseTest {
+  public String partition;
+  @DataProvider(name = "partitionName")
+  public Object[][] createPartitionTest() {
+    partition = "partition_" + MathUtil.getRandomString(10);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+    return new Object[][] {{partition}};
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "drop partition", dataProvider = "partitionName")
+  public void dropPartitionTest(String partitionName) {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropPartition(
+            DropPartitionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(partitionName)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Test(
+          description = "query float vector from partition ",
+          dependsOnMethods = "dropPartitionTest")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryFromDroppedPartition() {
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    List<String> partitions =
+            new ArrayList<String>() {
+              {
+                add(partition);
+              }
+            };
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionNames(partitions)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertEquals(queryResultsR.getException().getMessage(), "partition name "+partition+" not found");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "drop nonexistent partition")
+  public void dropNonexistentPartition() {
+    R<RpcStatus> rpcStatusR =
+            milvusClient.dropPartition(
+                    DropPartitionParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withPartitionName("NonexistentPartition")
+                            .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertEquals(rpcStatusR.getException().getMessage(), "DropPartition failed: partition NonexistentPartition does not exist");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/partition/GetPartitionStatisticsTest.java

@@ -0,0 +1,83 @@
+package com.zilliz.milvustest.partition;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.GetPartitionStatisticsResponse;
+import io.milvus.param.R;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.param.partition.DropPartitionParam;
+import io.milvus.param.partition.GetPartitionStatisticsParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+@Epic("Partition")
+@Feature("GetPartitionStatistics")
+public class GetPartitionStatisticsTest extends BaseTest {
+  public String partition;
+
+  @BeforeClass(description = "load partition")
+  public void initPartition() {
+    partition = "partition_" + MathUtil.getRandomString(10);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @AfterClass(description = "delete partition after test")
+  public void deletePartition() {
+    milvusClient.dropPartition(
+        DropPartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Get partition statistics")
+  public void getPartitionStatistics() {
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withPartitionName(partition)
+            .withFields(fields)
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    R<GetPartitionStatisticsResponse> partitionStatisticsResponseR =
+        milvusClient.getPartitionStatistics(
+            GetPartitionStatisticsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(partition)
+                .build());
+    Assert.assertEquals(partitionStatisticsResponseR.getStatus().intValue(), 0);
+    GetPartitionStatisticsResponse partitionStatisticsResponse =
+        partitionStatisticsResponseR.getData();
+    Assert.assertEquals(partitionStatisticsResponse.getStats(0).getValue(), "1000");
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Get nonexistent partition statistics")
+  public void getNonexistentPartitionStatistics() {
+
+    R<GetPartitionStatisticsResponse> partitionStatisticsResponseR =
+            milvusClient.getPartitionStatistics(
+                    GetPartitionStatisticsParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withPartitionName("NonexistentPartition")
+                            .build());
+    Assert.assertEquals(partitionStatisticsResponseR.getStatus().intValue(), 1);
+    Assert.assertEquals(partitionStatisticsResponseR.getException().getMessage(),"partitionID of partitionName:NonexistentPartition can not be find");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/partition/HasPartitionTest.java

@@ -0,0 +1,68 @@
+package com.zilliz.milvustest.partition;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.param.R;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.param.partition.DropPartitionParam;
+import io.milvus.param.partition.HasPartitionParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+@Epic("Partition")
+@Feature("HasPartition")
+public class HasPartitionTest extends BaseTest {
+  private String partition;
+
+  @BeforeClass(description = "init partition Name")
+  public void createPartitionTest() {
+    partition = "partition_" + MathUtil.getRandomString(10);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @AfterClass(description = "delete partition after test")
+  public void deletePartition() {
+    milvusClient.dropPartition(
+        DropPartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Check partition")
+  public void hasPartitionTest1() {
+    R<Boolean> booleanR =
+        milvusClient.hasPartition(
+            HasPartitionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(partition)
+                .build());
+    Assert.assertEquals(booleanR.getStatus().intValue(), 0);
+    Assert.assertTrue(booleanR.getData());
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "Check nonexistent partition")
+  public void hasPartitionWithNonexistentName() {
+    R<Boolean> booleanR =
+        milvusClient.hasPartition(
+            HasPartitionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(MathUtil.getRandomString(10))
+                .build());
+    Assert.assertEquals(booleanR.getStatus().intValue(), 0);
+    Assert.assertFalse(booleanR.getData());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/partition/LoadPartitionsTest.java

@@ -0,0 +1,86 @@
+package com.zilliz.milvustest.partition;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.param.partition.DropPartitionParam;
+import io.milvus.param.partition.LoadPartitionsParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+@Epic("Partition")
+@Feature("LoadPartitions")
+public class LoadPartitionsTest extends BaseTest {
+  private String partition;
+
+  @BeforeClass(description = "init partition Name")
+  public void createPartitionTest() {
+    partition = "partition_" + MathUtil.getRandomString(10);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @AfterClass(description = "delete partition after test")
+  public void deletePartition() {
+    milvusClient.dropPartition(
+        DropPartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "load partition")
+  public void loadPartitionSuccess() {
+    List<String> partitionNames =
+        new ArrayList<String>() {
+          {
+            add(partition);
+          }
+        };
+    R<RpcStatus> rpcStatusR =
+        milvusClient.loadPartitions(
+            LoadPartitionsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionNames(partitionNames)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "load nonexistent partition")
+  public void loadNonexistentPartition() {
+    String nonexsitPartition = "partition_" + MathUtil.getRandomString(10);
+    List<String> partitionNames =
+        new ArrayList<String>() {
+          {
+            add(nonexsitPartition);
+          }
+        };
+    R<RpcStatus> rpcStatusR =
+        milvusClient.loadPartitions(
+            LoadPartitionsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionNames(partitionNames)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        rpcStatusR.getException().getMessage(),
+        "partitionID of partitionName:" + nonexsitPartition + " can not be find");
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/partition/ReleasePartitionsTest.java

@@ -0,0 +1,94 @@
+package com.zilliz.milvustest.partition;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.partition.CreatePartitionParam;
+import io.milvus.param.partition.DropPartitionParam;
+import io.milvus.param.partition.LoadPartitionsParam;
+import io.milvus.param.partition.ReleasePartitionsParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Epic("Partition")
+@Feature("ReleasePartitions")
+public class ReleasePartitionsTest extends BaseTest {
+  public String partition;
+
+  @BeforeClass(description = "load partition")
+  public void initPartition() {
+    partition = "partition_" + MathUtil.getRandomString(10);
+    milvusClient.createPartition(
+        CreatePartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+    milvusClient.loadPartitions(
+        LoadPartitionsParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .addPartitionName(partition)
+            .build());
+  }
+
+  @AfterClass(description = "delete partition after test")
+  public void deletePartition() {
+    milvusClient.dropPartition(
+        DropPartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "release partition")
+  public void releasePartitionSuccess() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.releasePartitions(
+            ReleasePartitionsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .addPartitionName(partition)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
+
+  @Test(
+          description = "query from partition after release ",
+          dependsOnMethods = "releasePartitionSuccess")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryAfterReleasePartition() {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    List<String> partitions =
+            new ArrayList<String>() {
+              {
+                add(partition);
+              }
+            };
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionNames(partitions)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(queryResultsR.getException().getMessage().contains("checkIfLoaded failed when query"));
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/partition/ShowPartitionsTest.java

@@ -0,0 +1,41 @@
+package com.zilliz.milvustest.partition;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.ShowPartitionsResponse;
+import io.milvus.param.R;
+import io.milvus.param.partition.ShowPartitionsParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Epic("Partition")
+@Feature("ShowPartitions")
+public class ShowPartitionsTest extends BaseTest {
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "show partitions")
+  public void showPartitionTest() {
+    List<String> strings =
+        new ArrayList<String>() {
+          {
+            add(CommonData.defaultPartition);
+          }
+        };
+    R<ShowPartitionsResponse> showPartitionsResponseR =
+        milvusClient.showPartitions(
+            ShowPartitionsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionNames(strings)
+                .build());
+    Assert.assertEquals(showPartitionsResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(showPartitionsResponseR.getData().getPartitionIDsCount() > 1);
+
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/query/QueryAsyncTest.java

@@ -0,0 +1,977 @@
+package com.zilliz.milvustest.query;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.MutationResult;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import static com.zilliz.milvustest.util.MathUtil.combine;
+
+@Epic("Query")
+@Feature("QueryAsync")
+public class QueryAsyncTest extends BaseTest {
+  public String newBookName;
+
+  @BeforeClass(description = "load collection first")
+  public void loadCollection() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @DataProvider(name = "providerPartition")
+  public Object[][] providerPartition() {
+    return new Object[][] {{Boolean.FALSE}, {Boolean.TRUE}};
+  }
+
+  @AfterClass(description = "release collection after test")
+  public void releaseCollection() {
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @DataProvider(name = "providerConsistency")
+  public Object[][] providerConsistency() {
+    return new Object[][] {
+      {ConsistencyLevelEnum.STRONG},
+      {ConsistencyLevelEnum.BOUNDED},
+      {ConsistencyLevelEnum.EVENTUALLY}
+    };
+  }
+
+  @DataProvider(name = "IndexTypes")
+  public Object[][] provideIndexType() {
+    return new Object[][] {
+      {IndexType.IVF_FLAT},
+      {IndexType.IVF_SQ8},
+      {IndexType.IVF_PQ},
+      {IndexType.HNSW},
+      {IndexType.ANNOY},
+      {IndexType.RHNSW_FLAT},
+      {IndexType.RHNSW_PQ},
+      {IndexType.RHNSW_SQ}
+    };
+  }
+
+  @DataProvider(name = "MetricType")
+  public Object[][] providerMetricType() {
+    return new Object[][] {{MetricType.L2}, {MetricType.IP}};
+  }
+
+  @DataProvider(name = "FloatIndex")
+  public Object[][] providerIndexForFloatCollection() {
+    return combine(provideIndexType(), providerMetricType());
+  }
+
+  @DataProvider(name = "BinaryIndexTypes")
+  public Object[][] provideBinaryIndexType() {
+    return new Object[][] {{IndexType.BIN_IVF_FLAT}, {IndexType.BIN_FLAT}};
+  }
+
+  @DataProvider(name = "BinaryMetricType")
+  public Object[][] providerBinaryMetricType() {
+    return new Object[][] {
+      {MetricType.HAMMING},
+      {MetricType.JACCARD},
+      {MetricType.SUBSTRUCTURE},
+      {MetricType.SUPERSTRUCTURE},
+      {MetricType.TANIMOTO}
+    };
+  }
+
+  @DataProvider(name = "BinaryIndex")
+  public Object[][] providerIndexForBinaryCollection() {
+    return combine(provideBinaryIndexType(), providerBinaryMetricType());
+  }
+
+  @DataProvider(name = "provideIntExpressions")
+  public Object[][] provideIntExpression() {
+    return new Object[][] {
+      {"book_id > 10"},
+      {"book_id >= 10"},
+      {"book_id < 10"},
+      {"book_id <= 10"},
+      {"book_id == 10"},
+      {"book_id !=10"},
+      {"book_id in [10,20,30,40]"},
+      {"book_id not in [10]"},
+      {"10 < book_id < 50 "},
+      {"50 > book_id > 10 "},
+      {"10 <= book_id <=50 "},
+      {"10 <= book_id <50 "},
+      {"10 < book_id <=50 "},
+      {"book_id >10 and word_count > 10010 "},
+      {"book_id >10 and word_count >= 10110 "},
+      {"book_id in [10,20,30,40] and word_count >= 10010 "},
+      {"book_id not in [10,20,30,40] and word_count >= 10010 "},
+      {"book_id in [10,20,30,40] and word_count in [10010,10020,10030,10040] "},
+      {"book_id not in [10,20,30,40] and word_count not in [10010,10020,10030,10040] "}
+    };
+  }
+
+  @DataProvider(name = "provideStringExpressions")
+  public Object[][] provideStringExpression() {
+    return new Object[][] {
+      {" book_name > \"10\" "},
+      {" book_name > \"a\" "},
+      {" book_name >= \"a\" "},
+      {" book_name not in [\"a\"] "},
+      {" book_name > book_content "},
+      {" book_name >= book_content "},
+      {" book_name < book_content "},
+      {" book_name <= book_content "},
+      {" \"10\" < book_name  <= \"a\" "},
+      {" \"a\" <= book_name < \"a99\" "},
+      {" \"asa\" < book_name <= \"zaa\" "},
+      {" \"a\" <= book_name  and book_name >= \"99\" "},
+      {" book_name like \"国%\" "},
+      {" book_name like \"国%\" and book_name >\"abc\" "},
+      {" book_name like \"国%\" and book_content like\"1%\" "},
+      {" book_name like \"国%\" and book_content > \"1\" "}
+    };
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "query data async", dataProvider = "providerPartition")
+  public void queryAsyncTest(Boolean usePart) throws ExecutionException, InterruptedException {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper(CommonData.defaultVectorField).getDim(), 128);
+  }
+
+  @Test(description = "Int PK and  binary vector query ", dataProvider = "providerPartition")
+  @Severity(SeverityLevel.BLOCKER)
+  public void intPKAndBinaryVectorQuery(Boolean usePart) throws ExecutionException, InterruptedException {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields =
+            Arrays.asList("book_id", "word_count", CommonData.defaultBinaryVectorField);
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultBinaryCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper(CommonData.defaultBinaryVectorField).getDim());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    Assert.assertEquals(
+            wrapperQuery.getFieldWrapper(CommonData.defaultBinaryVectorField).getDim(), 128);
+  }
+
+  @Test(description = "String PK and float vector query", dataProvider = "providerPartition")
+  @Severity(SeverityLevel.BLOCKER)
+  public void stringPKAndFloatVectorQuery(Boolean usePart)throws ExecutionException, InterruptedException  {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields =
+            Arrays.asList("book_name", "book_content", CommonData.defaultVectorField);
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper(CommonData.defaultVectorField).getDim(), 128);
+  }
+
+  @Test(description = "String PK and binary vector query", dataProvider = "providerPartition")
+  @Severity(SeverityLevel.BLOCKER)
+  public void stringPKAndBinaryVectorQuery(Boolean usePart)throws ExecutionException, InterruptedException  {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields =
+            Arrays.asList("book_name", "book_content", CommonData.defaultBinaryVectorField);
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .withPartitionNames(
+                            usePart
+                                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                                    : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+    Assert.assertEquals(
+            wrapperQuery.getFieldWrapper(CommonData.defaultBinaryVectorField).getDim(), 128);
+  }
+
+  @Test(
+          description = "Int PK and  float vector query after insert new data",
+          dataProvider = "providerPartition")
+  @Severity(SeverityLevel.NORMAL)
+  public void intPKAndFloatVectorAfterInsert(Boolean usePart) throws ExecutionException, InterruptedException  {
+    // insert entity first
+    List<Long> book_id_array =
+            new ArrayList<Long>() {
+              {
+                add(8888L);
+              }
+            };
+    List<Long> word_count_array =
+            new ArrayList<Long>() {
+              {
+                add(18888L);
+              }
+            };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+            new ArrayList<List<Float>>() {
+              {
+                add(fs);
+              }
+            };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+            InsertParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                    .withFields(fields)
+                    .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_id == 8888";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().get(0), 8888L);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().get(0), 18888L);
+  }
+
+  @Test(
+          description = "String PK and  float vector query after insert new data",
+          dataProvider = "providerPartition")
+  @Severity(SeverityLevel.NORMAL)
+  public void stringPKAndFloatVectorAfterInsert(Boolean usePart) throws ExecutionException, InterruptedException  {
+    // insert entity first
+    newBookName = MathUtil.genRandomStringAndChinese(10);
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+            new ArrayList<String>() {
+              {
+                add(newBookName);
+              }
+            };
+    List<String> book_content_array =
+            new ArrayList<String>() {
+              {
+                add(newBookContent);
+              }
+            };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+            new ArrayList<List<Float>>() {
+              {
+                add(fs);
+              }
+            };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+            InsertParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+                    .withFields(fields)
+                    .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_name == \"" + newBookName + "\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+            wrapperQuery.getFieldWrapper("book_name").getFieldData().get(0), newBookName);
+    Assert.assertEquals(
+            wrapperQuery.getFieldWrapper("book_content").getFieldData().get(0), newBookContent);
+  }
+
+  @Test(
+          description = "Int PK and  float vector query after update ",
+          dataProvider = "providerPartition",
+          dependsOnMethods = "intPKAndFloatVectorAfterInsert")
+  @Severity(SeverityLevel.NORMAL)
+  public void intPKAndFloatVectorAfterUpdate(Boolean usePart) throws ExecutionException, InterruptedException  {
+    // delete first for update
+    R<MutationResult> mutationResultR =
+            milvusClient.delete(
+                    DeleteParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                            .withExpr("book_id in [8888]")
+                            .build());
+    // update entity first
+    List<Long> book_id_array =
+            new ArrayList<Long>() {
+              {
+                add(8888L);
+              }
+            };
+    List<Long> word_count_array =
+            new ArrayList<Long>() {
+              {
+                add(28888L);
+              }
+            };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+            new ArrayList<List<Float>>() {
+              {
+                add(fs);
+              }
+            };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+            InsertParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                    .withFields(fields)
+                    .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_id == 8888";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().get(0), 8888L);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().get(0), 28888L);
+  }
+
+  @Test(
+          description = "String PK and  float vector query after update",
+          dataProvider = "providerPartition",
+          dependsOnMethods = "stringPKAndFloatVectorAfterInsert")
+  @Severity(SeverityLevel.NORMAL)
+  public void stringPKAndFloatVectorAfterUpdate(Boolean usePart) throws ExecutionException, InterruptedException  {
+    // delete entity first
+    milvusClient.delete(
+            DeleteParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+                    .withExpr("book_name in [\"" + newBookName + "\"]")
+                    .build());
+    // update entity first
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+            new ArrayList<String>() {
+              {
+                add(newBookName);
+              }
+            };
+    List<String> book_content_array =
+            new ArrayList<String>() {
+              {
+                add(newBookContent);
+              }
+            };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+            new ArrayList<List<Float>>() {
+              {
+                add(fs);
+              }
+            };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+            InsertParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+                    .withFields(fields)
+                    .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_name == \"" + newBookName + "\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+            wrapperQuery.getFieldWrapper("book_name").getFieldData().get(0), newBookName);
+    Assert.assertEquals(
+            wrapperQuery.getFieldWrapper("book_content").getFieldData().get(0), newBookContent);
+  }
+
+  @Test(
+          description = "Int PK and  float vector query after delete data ",
+          dataProvider = "providerPartition")
+  @Severity(SeverityLevel.NORMAL)
+  public void intPKAndFloatVectorAfterDelete(Boolean usePart) throws ExecutionException, InterruptedException {
+    R<MutationResult> mutationResultR =
+            milvusClient.delete(
+                    DeleteParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                            .withExpr("book_id in [22,24,26,28]")
+                            .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_id in [22,24,26,28]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    Assert.assertEquals(
+            queryResultsR.getException().getMessage(), "empty collection");
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 26);
+  }
+
+  @Test(
+          description = "String PK and  float vector query after delete data ",
+          dataProvider = "providerPartition",
+          dependsOnMethods = {"stringPKAndFloatVectorAfterInsert", "stringPKAndFloatVectorAfterUpdate"})
+  @Severity(SeverityLevel.NORMAL)
+  public void StringPKAndFloatVectorAfterDelete(Boolean usePart) throws ExecutionException, InterruptedException  {
+    R<MutationResult> mutationResultR =
+            milvusClient.delete(
+                    DeleteParam.newBuilder()
+                            .withCollectionName(CommonData.defaultStringPKCollection)
+                            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+                            .withExpr("book_name in [\"" + newBookName + "\"]")
+                            .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_name == \"" + newBookName + "\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionNames(
+                            usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    Assert.assertEquals(
+            queryResultsR.getException().getMessage(), "empty collection");
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 26);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "query without expression", expectedExceptions = ParamException.class)
+  public void queryWithoutExpression()throws ExecutionException, InterruptedException  {
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultBinaryCollection)
+                    .withOutFields(outFields)
+                    .withExpr("")
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+            queryResultsR.getException().getMessage(), "Expression cannot be null or empty");
+  }
+
+  @Test(description = "query return empty ")
+  @Severity(SeverityLevel.MINOR)
+  public void queryReturnEmpty()throws ExecutionException, InterruptedException  {
+    String SEARCH_PARAM = "book_id in [-1,-2,-3,-4]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    Assert.assertEquals(
+            queryResultsR.getException().getMessage(), "empty collection");
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 26);
+  }
+
+  @Test(description = "query float vector with chinese ")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryByChineseExpress()throws ExecutionException, InterruptedException  {
+    String SEARCH_PARAM = "book_name like \"国%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 1);
+  }
+
+  @Test(description = "query String PK With Complex Express")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryStringPKWithComplexExpress()throws ExecutionException, InterruptedException  {
+    String SEARCH_PARAM = "book_name like \"国%\" and book_content like \"1%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 1);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Int pk query  with alias")
+  public void intPKQueryWithAlias()throws ExecutionException, InterruptedException  {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultAlias)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "Int PK query  with nonexistent alias")
+  public void intPKQueryWithNonexistentAlias()throws ExecutionException, InterruptedException  {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName("NonexistentAlias")
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    Assert.assertEquals(
+            queryResultsR.getException().getMessage(),
+            "DescribeCollection failed: can't find collection: NonexistentAlias");
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+  }
+
+  @Test(description = "String PK and float vector query with alias")
+  @Severity(SeverityLevel.CRITICAL)
+  public void stringPKQueryWithAlias() throws ExecutionException, InterruptedException {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKAlias)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+  }
+
+  @Test(description = "Int PK and float Vector query using each index", dataProvider = "FloatIndex")
+  @Severity(SeverityLevel.CRITICAL)
+  public void intPKAndFloatVectorQueryUsingEachIndex(IndexType indexType, MetricType metricType) throws ExecutionException, InterruptedException {
+    String newCollection = CommonFunction.createNewCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(newCollection)
+                            .withFieldName(CommonData.defaultVectorField)
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(metricType)
+                            .withIndexType(indexType)
+                            .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                            .withSyncMode(Boolean.FALSE)
+                            .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+            InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build());
+    // load
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(newCollection)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    // query
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(newCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    // drop collection
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+
+  @Test(
+          description = "String PK and binary Vector query using each index",
+          dataProvider = "BinaryIndex")
+  @Severity(SeverityLevel.CRITICAL)
+  public void stringPKAndBinaryVectorQueryUsingEachIndex(
+          IndexType indexType, MetricType metricType) throws ExecutionException, InterruptedException {
+    boolean b =
+            metricType.equals(MetricType.SUBSTRUCTURE) || metricType.equals(MetricType.SUPERSTRUCTURE);
+
+    if (indexType.equals(IndexType.BIN_IVF_FLAT) && b) {
+      return;
+    }
+    String stringPKAndBinaryCollection = CommonFunction.createStringPKAndBinaryCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(stringPKAndBinaryCollection)
+                            .withFieldName(CommonData.defaultBinaryVectorField)
+                            .withIndexName(CommonData.defaultBinaryIndex)
+                            .withMetricType(metricType)
+                            .withIndexType(indexType)
+                            .withExtraParam(CommonData.defaultExtraParam)
+                            .withSyncMode(Boolean.FALSE)
+                            .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateStringPKBinaryData(2000);
+    milvusClient.insert(
+            InsertParam.newBuilder()
+                    .withFields(fields)
+                    .withCollectionName(stringPKAndBinaryCollection)
+                    .build());
+    // load
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(stringPKAndBinaryCollection)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    // query
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(stringPKAndBinaryCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    if (b) {
+      return;
+    }
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+    // drop collection
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(stringPKAndBinaryCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Int PK query with each expression", dataProvider = "provideIntExpressions")
+  public void intPKQueryWithEachExpressions(String express)throws ExecutionException, InterruptedException  {
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withOutFields(outFields)
+                    .withExpr(express)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_id").getFieldData().size() >= 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("word_count").getFieldData().size() >= 1);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+          description = "String PK query with each expression",
+          dataProvider = "provideStringExpressions")
+  public void stringPKQueryWithEachExpressions(String express) throws ExecutionException, InterruptedException {
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .withOutFields(outFields)
+                    .withExpr(express)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() >= 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() >= 1);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+          description = "String PK and  float vector query with consistency",
+          dataProvider = "providerConsistency")
+  public void stringPKSearchWithConsistencyLevel(ConsistencyLevelEnum consistencyLevel) throws ExecutionException, InterruptedException {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withOutFields(outFields)
+                    .withConsistencyLevel(consistencyLevel)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Int PK and  float vector query without flush")
+  public void intPKAndFloatVectorQueryWithoutFlush()throws ExecutionException, InterruptedException  {
+    String newCollection = CommonFunction.createNewCollection();
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+            InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build());
+    // load
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder()
+                    .withCollectionName(newCollection)
+                    .withSyncLoad(true)
+                    .withSyncLoadWaitingInterval(500L)
+                    .withSyncLoadWaitingTimeout(30L)
+                    .build());
+    // query
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(newCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    // drop collection
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/query/QueryTest.java

@@ -0,0 +1,952 @@
+package com.zilliz.milvustest.query;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.MutationResult;
+import io.milvus.grpc.QueryResults;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.response.QueryResultsWrapper;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static com.zilliz.milvustest.util.MathUtil.combine;
+
+@Epic("Query")
+@Feature("Query")
+public class QueryTest extends BaseTest {
+  public String newBookName;
+
+  @BeforeClass(description = "load collection first")
+  public void loadCollection() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @DataProvider(name = "providerPartition")
+  public Object[][] providerPartition() {
+    return new Object[][] {{Boolean.FALSE}, {Boolean.TRUE}};
+  }
+
+  @AfterClass(description = "release collection after test")
+  public void releaseCollection() {
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @DataProvider(name = "providerConsistency")
+  public Object[][] providerConsistency() {
+    return new Object[][] {
+      {ConsistencyLevelEnum.STRONG},
+      {ConsistencyLevelEnum.BOUNDED},
+      {ConsistencyLevelEnum.EVENTUALLY}
+    };
+  }
+
+  @DataProvider(name = "IndexTypes")
+  public Object[][] provideIndexType() {
+    return new Object[][] {
+      {IndexType.IVF_FLAT},
+      {IndexType.IVF_SQ8},
+      {IndexType.IVF_PQ},
+      {IndexType.HNSW},
+      {IndexType.ANNOY},
+      {IndexType.RHNSW_FLAT},
+      {IndexType.RHNSW_PQ},
+      {IndexType.RHNSW_SQ}
+    };
+  }
+
+  @DataProvider(name = "MetricType")
+  public Object[][] providerMetricType() {
+    return new Object[][] {{MetricType.L2}, {MetricType.IP}};
+  }
+
+  @DataProvider(name = "FloatIndex")
+  public Object[][] providerIndexForFloatCollection() {
+    return combine(provideIndexType(), providerMetricType());
+  }
+
+  @DataProvider(name = "BinaryIndexTypes")
+  public Object[][] provideBinaryIndexType() {
+    return new Object[][] {{IndexType.BIN_IVF_FLAT}, {IndexType.BIN_FLAT}};
+  }
+
+  @DataProvider(name = "BinaryMetricType")
+  public Object[][] providerBinaryMetricType() {
+    return new Object[][] {
+      {MetricType.HAMMING},
+      {MetricType.JACCARD},
+      {MetricType.SUBSTRUCTURE},
+      {MetricType.SUPERSTRUCTURE},
+      {MetricType.TANIMOTO}
+    };
+  }
+
+  @DataProvider(name = "BinaryIndex")
+  public Object[][] providerIndexForBinaryCollection() {
+    return combine(provideBinaryIndexType(), providerBinaryMetricType());
+  }
+
+  @DataProvider(name = "provideIntExpressions")
+  public Object[][] provideIntExpression() {
+    return new Object[][] {
+      {"book_id > 10"},
+      {"book_id >= 10"},
+      {"book_id < 10"},
+      {"book_id <= 10"},
+      {"book_id == 10"},
+      {"book_id !=10"},
+      {"book_id in [10,20,30,40]"},
+      {"book_id not in [10]"},
+      {"10 < book_id < 50 "},
+      {"50 > book_id > 10 "},
+      {"10 <= book_id <=50 "},
+      {"10 <= book_id <50 "},
+      {"10 < book_id <=50 "},
+      {"book_id >10 and word_count > 10010 "},
+      {"book_id >10 and word_count >= 10110 "},
+      {"book_id in [10,20,30,40] and word_count >= 10010 "},
+      {"book_id not in [10,20,30,40] and word_count >= 10010 "},
+      {"book_id in [10,20,30,40] and word_count in [10010,10020,10030,10040] "},
+      {"book_id not in [10,20,30,40] and word_count not in [10010,10020,10030,10040] "}
+    };
+  }
+
+  @DataProvider(name = "provideStringExpressions")
+  public Object[][] provideStringExpression() {
+    return new Object[][] {
+      {" book_name > \"10\" "},
+      {" book_name > \"a\" "},
+      {" book_name >= \"a\" "},
+      {" book_name not in [\"a\"] "},
+      {" book_name > book_content "},
+      {" book_name >= book_content "},
+      {" book_name < book_content "},
+      {" book_name <= book_content "},
+      {" \"10\" < book_name  <= \"a\" "},
+      {" \"a\" <= book_name < \"a99\" "},
+      {" \"asa\" < book_name <= \"zaa\" "},
+      {" \"a\" <= book_name  and book_name >= \"99\" "},
+      {" book_name like \"国%\" "},
+      {" book_name like \"国%\" and book_name >\"abc\" "},
+      {" book_name like \"国%\" and book_content like\"1%\" "},
+      {" book_name like \"国%\" and book_content > \"1\" "}
+    };
+  }
+
+  @Test(description = "int PK and float vector query", dataProvider = "providerPartition")
+  @Severity(SeverityLevel.BLOCKER)
+  public void intPKAndFloatVectorQuery(Boolean usePart) {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper(CommonData.defaultVectorField).getDim(), 128);
+  }
+
+  @Test(description = "Int PK and  binary vector query ", dataProvider = "providerPartition")
+  @Severity(SeverityLevel.BLOCKER)
+  public void intPKAndBinaryVectorQuery(Boolean usePart) {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields =
+        Arrays.asList("book_id", "word_count", CommonData.defaultBinaryVectorField);
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper(CommonData.defaultBinaryVectorField).getDim());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    Assert.assertEquals(
+        wrapperQuery.getFieldWrapper(CommonData.defaultBinaryVectorField).getDim(), 128);
+  }
+
+  @Test(description = "String PK and float vector query", dataProvider = "providerPartition")
+  @Severity(SeverityLevel.BLOCKER)
+  public void stringPKAndFloatVectorQuery(Boolean usePart) {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields =
+        Arrays.asList("book_name", "book_content", CommonData.defaultVectorField);
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper(CommonData.defaultVectorField).getDim(), 128);
+  }
+
+  @Test(description = "String PK and binary vector query", dataProvider = "providerPartition")
+  @Severity(SeverityLevel.BLOCKER)
+  public void stringPKAndBinaryVectorQuery(Boolean usePart) {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields =
+        Arrays.asList("book_name", "book_content", CommonData.defaultBinaryVectorField);
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+    Assert.assertEquals(
+        wrapperQuery.getFieldWrapper(CommonData.defaultBinaryVectorField).getDim(), 128);
+  }
+
+  @Test(
+      description = "Int PK and  float vector query after insert new data",
+      dataProvider = "providerPartition")
+  @Severity(SeverityLevel.NORMAL)
+  public void intPKAndFloatVectorAfterInsert(Boolean usePart) throws InterruptedException {
+    // insert entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add(8889L);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(18888L);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_id == 8889";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().get(0), 8889L);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().get(0), 18888L);
+  }
+
+  @Test(
+      description = "String PK and  float vector query after insert new data",
+      dataProvider = "providerPartition")
+  @Severity(SeverityLevel.NORMAL)
+  public void stringPKAndFloatVectorAfterInsert(Boolean usePart) throws InterruptedException {
+    // insert entity first
+    newBookName = MathUtil.genRandomStringAndChinese(10);
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookName);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_name == \"" + newBookName + "\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+        wrapperQuery.getFieldWrapper("book_name").getFieldData().get(0), newBookName);
+    Assert.assertEquals(
+        wrapperQuery.getFieldWrapper("book_content").getFieldData().get(0), newBookContent);
+  }
+
+  @Test(
+      description = "Int PK and  float vector query after update ",
+      dataProvider = "providerPartition",
+      dependsOnMethods = "intPKAndFloatVectorAfterInsert")
+  @Severity(SeverityLevel.NORMAL)
+  public void intPKAndFloatVectorAfterUpdate(Boolean usePart) throws InterruptedException {
+    // delete first for update
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                .withExpr("book_id in [8889]")
+                .build());
+    // update entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add(8889L);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(28888L);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_id == 8889";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().get(0), 8889L);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().get(0), 28888L);
+  }
+
+  @Test(
+      description = "String PK and  float vector query after update",
+      dataProvider = "providerPartition",
+      dependsOnMethods = "stringPKAndFloatVectorAfterInsert")
+  @Severity(SeverityLevel.NORMAL)
+  public void stringPKAndFloatVectorAfterUpdate(Boolean usePart) throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withExpr("book_name in [\"" + newBookName + "\"]")
+            .build());
+    // update entity first
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookName);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_name == \"" + newBookName + "\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(
+        wrapperQuery.getFieldWrapper("book_name").getFieldData().get(0), newBookName);
+    Assert.assertEquals(
+        wrapperQuery.getFieldWrapper("book_content").getFieldData().get(0), newBookContent);
+  }
+
+  @Test(
+      description = "Int PK and  float vector query after delete data ",
+      dataProvider = "providerPartition")
+  @Severity(SeverityLevel.NORMAL)
+  public void intPKAndFloatVectorAfterDelete(Boolean usePart) throws InterruptedException {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                .withExpr("book_id in [22,24,26,28]")
+                .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_id in [22,24,26,28]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(
+        queryResultsR.getException().getMessage(), "empty collection or improper expression");
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 26);
+  }
+
+  @Test(
+      description = "String PK and  float vector query after delete data ",
+      dataProvider = "providerPartition",
+      dependsOnMethods = {"stringPKAndFloatVectorAfterInsert", "stringPKAndFloatVectorAfterUpdate"})
+  @Severity(SeverityLevel.NORMAL)
+  public void StringPKAndFloatVectorAfterDelete(Boolean usePart) throws InterruptedException {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(CommonData.defaultStringPKCollection)
+                .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+                .withExpr("book_name in [\"" + newBookName + "\"]")
+                .build());
+    Thread.sleep(2000);
+    String SEARCH_PARAM = "book_name == \"" + newBookName + "\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(
+        queryResultsR.getException().getMessage(), "empty collection or improper expression");
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 26);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "query without expression", expectedExceptions = ParamException.class)
+  public void queryWithoutExpression() {
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withOutFields(outFields)
+            .withExpr("")
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        queryResultsR.getException().getMessage(), "Expression cannot be null or empty");
+  }
+
+  @Test(description = "query return empty ")
+  @Severity(SeverityLevel.MINOR)
+  public void queryReturnEmpty() {
+    String SEARCH_PARAM = "book_id in [-1,-2,-3,-4]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 25);
+    Assert.assertEquals(
+        queryResultsR.getException().getMessage(), "empty collection or improper expression");
+  }
+
+  @Test(description = "query float vector with chinese ")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryByChineseExpress() {
+    String SEARCH_PARAM = "book_name like \"国%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 1);
+  }
+
+  @Test(description = "query String PK With Complex Express")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryStringPKWithComplexExpress() {
+    String SEARCH_PARAM = "book_name like \"国%\" and book_content like \"1%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 1);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Int pk query  with alias")
+  public void intPKQueryWithAlias() {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultAlias)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "Int PK query  with nonexistent alias")
+  public void intPKQueryWithNonexistentAlias() {
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName("NonexistentAlias")
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(
+        queryResultsR.getException().getMessage(),
+        "DescribeCollection failed: can't find collection: NonexistentAlias");
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+  }
+
+  @Test(description = "String PK and float vector query with alias")
+  @Severity(SeverityLevel.CRITICAL)
+  public void stringPKQueryWithAlias() {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKAlias)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+  }
+
+  @Test(description = "Int PK and float Vector query using each index", dataProvider = "FloatIndex")
+  @Severity(SeverityLevel.CRITICAL)
+  public void intPKAndFloatVectorQueryUsingEachIndex(IndexType indexType, MetricType metricType) {
+    String newCollection = CommonFunction.createNewCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(newCollection)
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // query
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    // drop collection
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+
+  @Test(
+      description = "String PK and binary Vector query using each index",
+      dataProvider = "BinaryIndex")
+  @Severity(SeverityLevel.CRITICAL)
+  public void stringPKAndBinaryVectorQueryUsingEachIndex(
+      IndexType indexType, MetricType metricType) {
+    boolean b =
+        metricType.equals(MetricType.SUBSTRUCTURE) || metricType.equals(MetricType.SUPERSTRUCTURE);
+
+    if (indexType.equals(IndexType.BIN_IVF_FLAT) && b) {
+      return;
+    }
+    String stringPKAndBinaryCollection = CommonFunction.createStringPKAndBinaryCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(stringPKAndBinaryCollection)
+                .withFieldName(CommonData.defaultBinaryVectorField)
+                .withIndexName(CommonData.defaultBinaryIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonData.defaultExtraParam)
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateStringPKBinaryData(2000);
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withFields(fields)
+            .withCollectionName(stringPKAndBinaryCollection)
+            .build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(stringPKAndBinaryCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // query
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(stringPKAndBinaryCollection)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    if (b) {
+      return;
+    }
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+    // drop collection
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(stringPKAndBinaryCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Int PK query with each expression", dataProvider = "provideIntExpressions")
+  public void intPKQueryWithEachExpressions(String express) {
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withOutFields(outFields)
+            .withExpr(express)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_id").getFieldData().size() >= 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("word_count").getFieldData().size() >= 1);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "String PK query with each expression",
+      dataProvider = "provideStringExpressions")
+  public void stringPKQueryWithEachExpressions(String express) {
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withOutFields(outFields)
+            .withExpr(express)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() >= 1);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() >= 1);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "String PK and  float vector query with consistency",
+      dataProvider = "providerConsistency")
+  public void stringPKSearchWithConsistencyLevel(ConsistencyLevelEnum consistencyLevel) {
+    String SEARCH_PARAM = "book_content like \"10%\"";
+    List<String> outFields = Arrays.asList("book_name", "book_content");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withOutFields(outFields)
+            .withConsistencyLevel(consistencyLevel)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    System.out.println(wrapperQuery.getFieldWrapper("book_name").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_content").getFieldData());
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_name").getFieldData().size() > 10);
+    Assert.assertTrue(wrapperQuery.getFieldWrapper("book_content").getFieldData().size() > 10);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Int PK and  float vector query without flush")
+  public void intPKAndFloatVectorQueryWithoutFlush() {
+    String newCollection = CommonFunction.createNewCollection();
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // query
+    String SEARCH_PARAM = "book_id in [2,4,6,8]";
+    List<String> outFields = Arrays.asList("book_id", "word_count");
+    QueryParam queryParam =
+        QueryParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withOutFields(outFields)
+            .withExpr(SEARCH_PARAM)
+            .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    // drop collection
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/search/SearchAsyncTest.java

@@ -0,0 +1,1789 @@
+package com.zilliz.milvustest.search;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.MutationResult;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.response.SearchResultsWrapper;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ExecutionException;
+
+import static com.zilliz.milvustest.util.MathUtil.combine;
+
+@Epic("Search")
+@Feature("SearchAsync")
+public class SearchAsyncTest extends BaseTest {
+  public String newBookName;
+  public String newBookNameBin;
+
+  @BeforeClass(description = "load collection first")
+  public void loadCollection() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @AfterClass(description = "release collection after test")
+  public void releaseCollection() {
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @DataProvider(name = "providerPartition")
+  public Object[][] providerPartition() {
+    return new Object[][] {{Boolean.FALSE}, {Boolean.TRUE}};
+  }
+
+  @DataProvider(name = "providerConsistency")
+  public Object[][] providerConsistency() {
+    return new Object[][] {
+      {ConsistencyLevelEnum.STRONG},
+      {ConsistencyLevelEnum.BOUNDED},
+      {ConsistencyLevelEnum.EVENTUALLY}
+    };
+  }
+
+  @DataProvider(name = "IndexTypes")
+  public Object[][] provideIndexType() {
+    return new Object[][] {
+      {IndexType.IVF_FLAT},
+      {IndexType.IVF_SQ8},
+      {IndexType.IVF_PQ},
+      {IndexType.HNSW},
+      {IndexType.ANNOY},
+      {IndexType.RHNSW_FLAT},
+      {IndexType.RHNSW_PQ},
+      {IndexType.RHNSW_SQ}
+    };
+  }
+
+  @DataProvider(name = "MetricType")
+  public Object[][] providerMetricType() {
+    return new Object[][] {{MetricType.L2}, {MetricType.IP}};
+  }
+
+  @DataProvider(name = "FloatIndex")
+  public Object[][] providerIndexForFloatCollection() {
+    return combine(provideIndexType(), providerMetricType());
+  }
+
+  @DataProvider(name = "BinaryIndexTypes")
+  public Object[][] provideBinaryIndexType() {
+    return new Object[][] {{IndexType.BIN_IVF_FLAT}, {IndexType.BIN_FLAT}};
+  }
+
+  @DataProvider(name = "BinaryMetricType")
+  public Object[][] providerBinaryMetricType() {
+    return new Object[][] {
+      {MetricType.HAMMING},
+      {MetricType.JACCARD},
+      {MetricType.SUBSTRUCTURE},
+      {MetricType.SUPERSTRUCTURE},
+      {MetricType.TANIMOTO}
+    };
+  }
+
+  @DataProvider(name = "BinaryIndex")
+  public Object[][] providerIndexForBinaryCollection() {
+    return combine(provideBinaryIndexType(), providerBinaryMetricType());
+  }
+
+  @DataProvider(name = "provideIntExpressions")
+  public Object[][] provideIntExpression() {
+    return new Object[][] {
+      {"book_id > 10"},
+      {"book_id >= 10"},
+      {"book_id < 10"},
+      {"book_id <= 10"},
+      {"book_id == 10"},
+      {"book_id !=10"},
+      {"book_id in [10,20,30,40]"},
+      {"book_id not in [10]"},
+      {"10 < book_id < 50 "},
+      {"50 > book_id > 10 "},
+      {"10 <= book_id <=50 "},
+      {"10 <= book_id <50 "},
+      {"10 < book_id <=50 "},
+      {"book_id >10 and word_count > 10010 "},
+      {"book_id >10 and word_count >= 10110 "},
+      {"book_id in [10,20,30,40] and word_count >= 10010 "},
+      {"book_id not in [10,20,30,40] and word_count >= 10010 "},
+      {"book_id in [10,20,30,40] and word_count in [10010,10020,10030,10040] "},
+      {"book_id not in [10,20,30,40] and word_count not in [10010,10020,10030,10040] "}
+    };
+  }
+
+  @DataProvider(name = "provideStringExpressions")
+  public Object[][] provideStringExpression() {
+    return new Object[][] {
+      {" book_name > \"10\" "},
+      {" book_name > \"a\" "},
+      {" book_name >= \"a\" "},
+      {" book_name not in [\"a\"] "},
+      {" book_name > book_content "},
+      {" book_name >= book_content "},
+      {" book_name < book_content "},
+      {" book_name <= book_content "},
+      {" \"10\" < book_name  <= \"a\" "},
+      {" \"a\" <= book_name < \"a99\" "},
+      {" \"asa\" < book_name <= \"zaa\" "},
+      {" \"a\" <= book_name  and book_name >= \"99\" "},
+      {" book_name like \"国%\" "},
+      {" book_name like \"国%\" and book_name >\"abc\" "},
+      {" book_name like \"国%\" and book_content like\"1%\" "},
+      {" book_name like \"国%\" and book_content > \"1\" "}
+    };
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description =
+          "Conducts ANN async search on a vector field. Use expression to do filtering before search.",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearchAsync(Boolean usePart) {
+    final Integer SEARCH_K = 2; // TopK
+    final String SEARCH_PARAM = "{\"nprobe\":100}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Conduct a hybrid search async", dataProvider = "providerPartition")
+  public void intPKAndFloatVectorHybridSearchAsync(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Conduct a search with  binary vector async",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearchAsync(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Conduct a hybrid  binary vector search async",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorHybridSearchAsync(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Conduct float vector Async search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndFloatVectorSearchAsync(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Conduct float vector async search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndFloatVectorHybridSearchAsync(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_name like \"a%\" ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Conduct binary vector async search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndBinaryVectorSearchAsync(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Conduct binary vector async search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndBinaryVectorHybridSearchAsync(Boolean usePart) {
+    Integer SEARCH_K = 20; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_name like \"国%\" ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(
+          searchResultsWrapper.getFieldData("book_name", 0).size(), SEARCH_K.intValue());
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Async search in nonexistent  partition")
+  public void searchAsyncInNonexistentPartition() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(Arrays.asList("nonexistent"))
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 1);
+      Assert.assertEquals(
+          rListenableFuture.get().getException().getMessage(),
+          "partition name nonexistent not found");
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search async float vector  with error vectors value)")
+  public void searchAsyncWithErrorVectors() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(2)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 1);
+      Assert.assertTrue(
+          rListenableFuture.get().getException().getMessage().contains("fail to search"));
+      System.out.println(rListenableFuture.get().getException().getMessage());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "search async binary vector with error MetricType",
+      expectedExceptions = ParamException.class)
+  public void binarySearchAsyncWithErrorMetricType() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withMetricType(MetricType.IP)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 1);
+      Assert.assertTrue(
+          rListenableFuture
+              .get()
+              .getException()
+              .getMessage()
+              .contains("binary search not support metric type: METRIC_INNER_PRODUCT"));
+      System.out.println(rListenableFuture.get().getException().getMessage());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "search async  with error MetricType ",
+      expectedExceptions = ParamException.class)
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/313")
+  public void searchAsyncWithErrorMetricType() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 1);
+      Assert.assertTrue(
+          rListenableFuture
+              .get()
+              .getException()
+              .getMessage()
+              .contains("Target vector is float but metric type is incorrect"));
+      System.out.println(rListenableFuture.get().getException().getMessage());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "search async with empty vector", expectedExceptions = ParamException.class)
+  public void searchAsyncWithEmptyVector() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = new ArrayList<>();
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 1);
+      Assert.assertTrue(
+          rListenableFuture
+              .get()
+              .getException()
+              .getMessage()
+              .contains("Target vectors can not be empty"));
+      System.out.println(rListenableFuture.get().getException().getMessage());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(
+      description = "binary search async with empty vector",
+      expectedExceptions = ParamException.class)
+  public void binarySearchAsyncWithEmptyVector() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = new ArrayList<>();
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 1);
+      Assert.assertTrue(
+          rListenableFuture
+              .get()
+              .getException()
+              .getMessage()
+              .contains("Target vectors can not be empty"));
+      System.out.println(rListenableFuture.get().getException().getMessage());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and float vector search async after insert the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearchAsyncAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add(9999L);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).get(0), 9999L);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and binary vector search async after insert the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearchAsyncAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add(9999L);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).get(0), 9999L);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search async after insert the entity",
+      dataProvider = "providerPartition")
+  public void stringPKAndFloatVectorSearchAsyncAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    newBookName = MathUtil.genRandomStringAndChinese(10);
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    System.out.println("newBookContent:" + newBookContent);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookName);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(
+          searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookName);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search async after insert the entity",
+      dataProvider = "providerPartition")
+  public void stringPKAndBinaryVectorSearchAsyncAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    newBookNameBin = MathUtil.genRandomStringAndChinese(10);
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookNameBin);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(
+          searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookNameBin);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and float vector search async after update the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearchAsyncAfterUpdateEntity(Boolean usePart)
+      throws InterruptedException {
+    Random random = new Random();
+    int id = random.nextInt(2000);
+    // update entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add((long) id);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and binary vector search async after update the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearchAsyncAfterUpdateEntity(Boolean usePart)
+      throws InterruptedException {
+    Random random = new Random();
+    int id = random.nextInt(2000);
+    // update entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add((long) id);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search async after update the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = "stringPKAndFloatVectorSearchAsyncAfterInsertNewEntity")
+  public void stringPKAndFloatVectorSearchAsyncAfterUpdateNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withExpr("book_name in [\"" + newBookName + "\"]")
+            .build());
+    Thread.sleep(4000);
+    // update entity first
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    System.out.println("newBookContent:" + newBookContent);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookName);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+            .withExpr("book_name == \"" + newBookName + "\"")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(
+          searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookName);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search async after update the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = "stringPKAndBinaryVectorSearchAsyncAfterInsertNewEntity")
+  public void stringPKAndBinaryVectorSearchAsyncAfterUpdateNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withExpr("book_name in [\"" + newBookNameBin + "\"]")
+            .build());
+    Thread.sleep(2000);
+    // insert entity first
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookNameBin);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+            .withExpr("book_name == \"" + newBookNameBin + "\"")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(
+          searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookNameBin);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and float vector search async after delete data",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearchAsyncAfterDelete(Boolean usePart)
+      throws InterruptedException {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                .withExpr("book_id in [1,2,3]")
+                .build());
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+    Thread.sleep(2000);
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id in [1,2,3] ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResults searchResults = rListenableFuture.get().getData();
+      Assert.assertEquals(searchResults.getResults().getFieldsDataCount(), 0);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and binary vector search async after delete data",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearchAsyncAfterDelete(Boolean usePart)
+      throws InterruptedException {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(CommonData.defaultBinaryCollection)
+                .withPartitionName(usePart ? CommonData.defaultBinaryPartition : "")
+                .withExpr("book_id in [1,2,3]")
+                .build());
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+    Thread.sleep(2000);
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id in [1,2,3] ")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResults searchResults = rListenableFuture.get().getData();
+      Assert.assertEquals(searchResults.getResults().getFieldsDataCount(), 0);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search after delete the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = {
+        "stringPKAndFloatVectorSearchAsyncAfterInsertNewEntity",
+        "stringPKAndFloatVectorSearchAsyncAfterUpdateNewEntity"
+      })
+  public void stringPKAndFloatVectorSearchAsyncAfterDelete(Boolean usePart)
+      throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withExpr("book_name in [\"" + newBookName + "\"]")
+            .build());
+    Thread.sleep(2000);
+
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr("book_name in [\"" + newBookName + "\"]")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResults searchResults = rListenableFuture.get().getData();
+      Assert.assertEquals(searchResults.getStatus().getReason(), "search result is empty");
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search async after delete the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = {
+        "stringPKAndBinaryVectorSearchAsyncAfterInsertNewEntity",
+        "stringPKAndBinaryVectorSearchAsyncAfterUpdateNewEntity"
+      })
+  public void stringPKAndBinaryVectorSearchAsyncAfterDelete(Boolean usePart)
+      throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withExpr("book_name in [\"" + newBookNameBin + "\"]")
+            .build());
+    Thread.sleep(2000);
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr("book_name in [\"" + newBookNameBin + "\"]")
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResults searchResults = rListenableFuture.get().getData();
+      Assert.assertEquals(searchResults.getStatus().getReason(), "search result is empty");
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "int PK and float vector search async by alias")
+  public void intPKAndFloatVectorSearchAsyncByAlias() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultAlias)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "int PK and float vector search async by alias")
+  public void intPKAndFloatVectorSearchAsyncByNonexistentAlias() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName("NonexistentAlias")
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 1);
+      Assert.assertEquals(
+          rListenableFuture.get().getException().getMessage(),
+          "DescribeCollection failed: can't find collection: NonexistentAlias");
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "int pk and binary vector search async by alias")
+  public void intPKAndBinaryVectorSearchAsyncByAlias() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryAlias)
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Int pk search async with each consistency level",
+      dataProvider = "providerConsistency")
+  public void intPKSearchAsyncWithConsistencyLevel(ConsistencyLevelEnum consistencyLevel) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withConsistencyLevel(consistencyLevel)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "String pk search async with each consistency level",
+      dataProvider = "providerConsistency")
+  public void stringPKSearchAsyncWithConsistencyLevel(ConsistencyLevelEnum consistencyLevel) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(consistencyLevel)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Int PK and float vector search async with each index",
+      dataProvider = "FloatIndex")
+  public void intPKAndFloatVectorSearchAsyncWithEachIndex(
+      IndexType indexType, MetricType metricType) {
+    String newCollection = CommonFunction.createNewCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(newCollection)
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // search
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withMetricType(metricType)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+    // drop collection
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "String PK and Binary vector search async with each index",
+      dataProvider = "BinaryIndex")
+  public void stringPKAndBinaryVectorSearchAsyncWithEachIndex(
+      IndexType indexType, MetricType metricType) {
+    boolean b =
+        metricType.equals(MetricType.SUBSTRUCTURE) || metricType.equals(MetricType.SUPERSTRUCTURE);
+    if (indexType.equals(IndexType.BIN_IVF_FLAT) && b) {
+      return;
+    }
+    String stringPKAndBinaryCollection = CommonFunction.createStringPKAndBinaryCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(stringPKAndBinaryCollection)
+                .withFieldName(CommonData.defaultBinaryVectorField)
+                .withIndexName(CommonData.defaultBinaryIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonData.defaultExtraParam)
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateStringPKBinaryData(2000);
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withFields(fields)
+            .withCollectionName(stringPKAndBinaryCollection)
+            .build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(stringPKAndBinaryCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // search
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(stringPKAndBinaryCollection)
+            .withMetricType(metricType)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      if (b) {
+        return;
+      }
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+    // drop collection
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(stringPKAndBinaryCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Int PK search async with each expression",
+      dataProvider = "provideIntExpressions")
+  public void intPKSearchAsyncWithEachExpressions(String express) {
+    Integer SEARCH_K = 4; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(express)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertTrue(searchResultsWrapper.getFieldData("book_id", 0).size() >= 1);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "String PK search async with each expressions",
+      dataProvider = "provideStringExpressions")
+  public void stringPKSearchAsyncWithEachExpressions(String expression) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(expression)
+            .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    try {
+      Assert.assertEquals(rListenableFuture.get().getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+          new SearchResultsWrapper(rListenableFuture.get().getData().getResults());
+      Assert.assertTrue(searchResultsWrapper.getFieldData("book_name", 0).size() >= 1);
+      System.out.println(rListenableFuture.get().getData());
+    } catch (InterruptedException | ExecutionException e) {
+      Assert.fail(e.getMessage());
+    }
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/search/SearchTest.java

@@ -0,0 +1,2024 @@
+package com.zilliz.milvustest.search;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import com.zilliz.milvustest.common.CommonFunction;
+import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.common.clientenum.ConsistencyLevelEnum;
+import io.milvus.exception.ParamException;
+import io.milvus.grpc.DataType;
+import io.milvus.grpc.MutationResult;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.param.index.CreateIndexParam;
+import io.milvus.response.SearchResultsWrapper;
+import io.qameta.allure.*;
+import lombok.Data;
+import org.checkerframework.checker.units.qual.A;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+
+import static com.zilliz.milvustest.util.MathUtil.combine;
+
+@Epic("Search")
+@Feature("Search")
+public class SearchTest extends BaseTest {
+  public String newBookName;
+  public String newBookNameBin;
+
+  @BeforeClass(description = "load collection first")
+  public void loadCollection() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @AfterClass(description = "release collection after test")
+  public void releaseCollection() {
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .build());
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .build());
+  }
+
+  @DataProvider(name = "providerPartition")
+  public Object[][] providerPartition() {
+    return new Object[][] {{Boolean.FALSE}, {Boolean.TRUE}};
+  }
+
+  @DataProvider(name = "providerConsistency")
+  public Object[][] providerConsistency() {
+    return new Object[][] {
+      {ConsistencyLevelEnum.STRONG},
+      {ConsistencyLevelEnum.BOUNDED},
+      {ConsistencyLevelEnum.EVENTUALLY}
+    };
+  }
+
+  @DataProvider(name = "IndexTypes")
+  public Object[][] provideIndexType() {
+    return new Object[][] {
+      {IndexType.IVF_FLAT},
+      {IndexType.IVF_SQ8},
+      {IndexType.IVF_PQ},
+      {IndexType.HNSW},
+      {IndexType.ANNOY},
+      {IndexType.RHNSW_FLAT},
+      {IndexType.RHNSW_PQ},
+      {IndexType.RHNSW_SQ}
+    };
+  }
+
+  @DataProvider(name = "MetricType")
+  public Object[][] providerMetricType() {
+    return new Object[][] {{MetricType.L2}, {MetricType.IP}};
+  }
+
+  @DataProvider(name = "FloatIndex")
+  public Object[][] providerIndexForFloatCollection() {
+    return combine(provideIndexType(), providerMetricType());
+  }
+
+  @DataProvider(name = "BinaryIndexTypes")
+  public Object[][] provideBinaryIndexType() {
+    return new Object[][] {{IndexType.BIN_IVF_FLAT}, {IndexType.BIN_FLAT}};
+  }
+
+  @DataProvider(name = "BinaryMetricType")
+  public Object[][] providerBinaryMetricType() {
+    return new Object[][] {
+      {MetricType.HAMMING},
+      {MetricType.JACCARD},
+      {MetricType.SUBSTRUCTURE},
+      {MetricType.SUPERSTRUCTURE},
+      {MetricType.TANIMOTO}
+    };
+  }
+
+  @DataProvider(name = "BinaryIndex")
+  public Object[][] providerIndexForBinaryCollection() {
+    return combine(provideBinaryIndexType(), providerBinaryMetricType());
+  }
+
+  @DataProvider(name="provideIntExpressions")
+  public Object[][] provideIntExpression(){
+    return new Object[][]{
+            {"book_id > 10"},
+            {"book_id >= 10"},
+            {"book_id < 10"},
+            {"book_id <= 10"},
+            {"book_id == 10"},
+            {"book_id !=10"},
+            {"book_id in [10,20,30,40]"},
+            {"book_id not in [10]"},
+            {"10 < book_id < 50 "},
+            {"50 > book_id > 10 "},
+            {"10 <= book_id <=50 "},
+            {"10 <= book_id <50 "},
+            {"10 < book_id <=50 "},
+            {"book_id >10 and word_count > 10010 "},
+            {"book_id >10 and word_count >= 10110 "},
+            {"book_id in [10,20,30,40] and word_count >= 10010 "},
+            {"book_id not in [10,20,30,40] and word_count >= 10010 "},
+            {"book_id in [10,20,30,40] and word_count in [10010,10020,10030,10040] "},
+            {"book_id not in [10,20,30,40] and word_count not in [10010,10020,10030,10040] "}
+
+    };
+  }
+  @DataProvider(name="provideStringExpressions")
+  public Object[][] provideStringExpression(){
+    return new Object[][]{
+            {" book_name > \"10\" "},
+            {" book_name > \"a\" "},
+            {" book_name >= \"a\" "},
+            {" book_name not in [\"a\"] "},
+            {" book_name > book_content "},
+            {" book_name >= book_content "},
+            {" book_name < book_content "},
+            {" book_name <= book_content "},
+            {" \"10\" < book_name  <= \"a\" "},
+            {" \"a\" <= book_name < \"a99\" "},
+            {" \"asa\" < book_name <= \"zaa\" "},
+            {" \"a\" <= book_name  and book_name >= \"99\" "},
+            {" book_name like \"国%\" "},
+            {" book_name like \"国%\" and book_name >\"abc\" "},
+            {" book_name like \"国%\" and book_content like\"1%\" "},
+            {" book_name like \"国%\" and book_content > \"1\" "}
+    };
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description =
+          "Conducts ANN search on a vector field. Use expression to do filtering before search.",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearch(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Conduct a hybrid search", dataProvider = "providerPartition")
+  public void intPKAndFloatVectorHybridSearch(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertTrue(searchResultsR.getData().getResults().getIds().getIntId().getData(0) > 1000);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Conduct a search with  binary vector", dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearch(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    System.out.println(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
+    Assert.assertEquals(
+        searchResultsR.getData().getResults().getIds().getIntId().getDataCount(), 2);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Conduct a hybrid  binary vector search", dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorHybridSearch(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(searchResultsR.getData().getResults().getIds().getIntId().getData(0) > 1000);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Conduct float vector search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndFloatVectorSearch(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Conduct float vector search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndFloatVectorHybridSearch(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_name like \"a%\" ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Conduct binary vector search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndBinaryVectorSearch(Boolean usePart) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "Conduct binary vector search with String PK",
+      dataProvider = "providerPartition")
+  public void stringPKAndBinaryVectorHybridSearch(Boolean usePart) {
+    Integer SEARCH_K = 20; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_name like \"国%\" ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(
+        searchResultsWrapper.getFieldData("book_name", 0).size(), SEARCH_K.intValue());
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  /*  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "int PK and float vector search by partition")
+  public void intPKAndFloatVectorSearchByPartition() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
+    Assert.assertEquals(
+        searchResultsR.getData().getResults().getIds().getIntId().getDataCount(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "int PK and binary vector search by partition")
+  public void intPKAndBinaryVectorSearchByPartition() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultBinaryCollection)
+                    .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
+                    .withMetricType(MetricType.JACCARD)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultBinaryVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
+    Assert.assertEquals(
+            searchResultsR.getData().getResults().getIds().getIntId().getDataCount(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "String PK and float vector search by partition")
+  public void stringPKAndFloatVectorSearchByPartition() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withPartitionNames(Arrays.asList(CommonData.defaultStringPKPartition))
+                    .withMetricType(MetricType.L2)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
+    SearchResultsWrapper searchResultsWrapper =
+            new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(
+            searchResultsWrapper.getFieldData("book_name",0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "string PK and binary vector search by partition")
+  public void stringPKAndBinaryVectorSearchByPartition() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+                    .withPartitionNames(Arrays.asList(CommonData.defaultStringPKBinaryPartition))
+                    .withMetricType(MetricType.JACCARD)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultBinaryVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
+    SearchResultsWrapper searchResultsWrapper =
+            new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(
+            searchResultsWrapper.getFieldData("book_name",0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }*/
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search in nonexistent  partition")
+  public void searchInNonexistentPartition() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(Arrays.asList("nonexistent"))
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        searchResultsR.getException().getMessage(), "partition name nonexistent not found");
+    System.out.println(searchResultsR);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search float vector  with error vectors value)")
+  public void searchWithErrorVectors() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(2)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(searchResultsR.getException().getMessage().contains("fail to search"));
+    System.out.println(searchResultsR.getException().getMessage());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "search binary vector with error MetricType",
+      expectedExceptions = ParamException.class)
+  public void binarySearchWithErrorMetricType() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withMetricType(MetricType.IP)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        searchResultsR
+            .getException()
+            .getMessage()
+            .contains("binary search not support metric type: METRIC_INNER_PRODUCT"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search with error MetricType", expectedExceptions = ParamException.class)
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/313")
+  public void SearchWithErrorMetricType() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertTrue(
+        searchResultsR
+            .getException()
+            .getMessage()
+            .contains("binary search not support metric type: METRIC_INNER_JACCARD"));
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "search with empty vector", expectedExceptions = ParamException.class)
+  public void searchWithEmptyVector() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = new ArrayList<>();
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        searchResultsR.getException().getMessage().contains("Target vectors can not be empty"));
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "binary search with empty vector", expectedExceptions = ParamException.class)
+  public void binarySearchWithEmptyVector() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = new ArrayList<>();
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id > 1000 ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        searchResultsR.getException().getMessage().contains("Target vectors can not be empty"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and float vector search after insert the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearchAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add(9999L);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).get(0), 9999L);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and binary vector search after insert the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearchAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add(9999L);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).get(0), 9999L);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search after insert the entity",
+      dataProvider = "providerPartition")
+  public void stringPKAndFloatVectorSearchAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    newBookName = MathUtil.genRandomStringAndChinese(10);
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    System.out.println("newBookContent:" + newBookContent);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookName);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+                .withExpr("book_name == \"" + newBookName + "\"")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(
+        searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookName);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and binary vector search after insert the entity",
+      dataProvider = "providerPartition")
+  public void stringPKAndBinaryVectorSearchAfterInsertNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // insert entity first
+    newBookNameBin = MathUtil.genRandomStringAndChinese(10);
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookNameBin);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+                .withExpr("book_name == \"" + newBookNameBin + "\"")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(
+        searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookNameBin);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and float vector search after update the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearchAfterUpdateEntity(Boolean usePart)
+      throws InterruptedException {
+    Random random = new Random();
+    int id = random.nextInt(2000);
+    // update entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add((long) id);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(usePart ? CommonData.defaultPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and binary vector search after update the entity",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearchAfterUpdateEntity(Boolean usePart)
+      throws InterruptedException {
+    Random random = new Random();
+    int id = random.nextInt(2000);
+    // update entity first
+    List<Long> book_id_array =
+        new ArrayList<Long>() {
+          {
+            add((long) id);
+          }
+        };
+    List<Long> word_count_array =
+        new ArrayList<Long>() {
+          {
+            add(19999L);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id", "word_count");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("word_count", 0).get(0), 19999L);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search after update the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = "stringPKAndFloatVectorSearchAfterInsertNewEntity")
+  public void stringPKAndFloatVectorSearchAfterUpdateNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withExpr("book_name in [\"" + newBookName + "\"]")
+            .build());
+    Thread.sleep(4000);
+    // update entity first
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    System.out.println("newBookContent:" + newBookContent);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookName);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+                .withExpr("book_name == \"" + newBookName + "\"")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(
+        searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookName);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search after update the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = "stringPKAndBinaryVectorSearchAfterInsertNewEntity")
+  public void stringPKAndBinaryVectorSearchAfterUpdateNewEntity(Boolean usePart)
+      throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withExpr("book_name in [\"" + newBookNameBin + "\"]")
+            .build());
+    Thread.sleep(2000);
+    // insert entity first
+    String newBookContent = MathUtil.genRandomStringAndChinese(20);
+    List<String> book_name_array =
+        new ArrayList<String>() {
+          {
+            add(newBookNameBin);
+          }
+        };
+    List<String> book_content_array =
+        new ArrayList<String>() {
+          {
+            add(newBookContent);
+          }
+        };
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_name", DataType.VarChar, book_name_array));
+    fields.add(new InsertParam.Field("book_content", DataType.VarChar, book_content_array));
+    fields.add(
+        new InsertParam.Field(
+            CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withFields(fields)
+            .build());
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(ConsistencyLevelEnum.STRONG)
+                .withExpr("book_name == \"" + newBookNameBin + "\"")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(
+        searchResultsWrapper.getFieldData("book_content", 0).get(0), newBookContent);
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).get(0), newBookNameBin);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and float vector search after delete data",
+      dataProvider = "providerPartition")
+  public void intPKAndFloatVectorSearchAfterDelete(Boolean usePart) throws InterruptedException {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(usePart ? CommonData.defaultPartition : "")
+                .withExpr("book_id in [1,2,3]")
+                .build());
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+    Thread.sleep(2000);
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id in [1,2,3] ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    System.out.println(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getResults().getFieldsDataCount(), 0);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "int PK and binary vector search after delete data",
+      dataProvider = "providerPartition")
+  public void intPKAndBinaryVectorSearchAfterDelete(Boolean usePart) throws InterruptedException {
+    R<MutationResult> mutationResultR =
+        milvusClient.delete(
+            DeleteParam.newBuilder()
+                .withCollectionName(CommonData.defaultBinaryCollection)
+                .withPartitionName(usePart ? CommonData.defaultBinaryPartition : "")
+                .withExpr("book_id in [1,2,3]")
+                .build());
+    Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+    Thread.sleep(2000);
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultBinaryPartition) : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr(" book_id in [1,2,3] ")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    System.out.println(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getResults().getFieldsDataCount(), 0);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search after delete the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = {
+        "stringPKAndFloatVectorSearchAfterInsertNewEntity",
+        "stringPKAndFloatVectorSearchAfterUpdateNewEntity"
+      })
+  public void stringPKAndFloatVectorSearchAfterDelete(Boolean usePart) throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKPartition : "")
+            .withExpr("book_name in [\"" + newBookName + "\"]")
+            .build());
+    Thread.sleep(2000);
+
+    List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+    List<List<Float>> book_intro_array =
+        new ArrayList<List<Float>>() {
+          {
+            add(fs);
+          }
+        };
+
+    Thread.sleep(2000);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withPartitionNames(
+                usePart ? Arrays.asList(CommonData.defaultStringPKPartition) : Arrays.asList())
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr("book_name in [\"" + newBookName + "\"]")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getStatus().getReason(), "search result is empty");
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "string PK and float vector search after delete the entity",
+      dataProvider = "providerPartition",
+      dependsOnMethods = {
+        "stringPKAndBinaryVectorSearchAfterInsertNewEntity",
+        "stringPKAndBinaryVectorSearchAfterUpdateNewEntity"
+      })
+  public void stringPKAndBinaryVectorSearchAfterDelete(Boolean usePart)
+      throws InterruptedException {
+    // delete entity first
+    milvusClient.delete(
+        DeleteParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionName(usePart ? CommonData.defaultStringPKBinaryPartition : "")
+            .withExpr("book_name in [\"" + newBookNameBin + "\"]")
+            .build());
+    Thread.sleep(2000);
+    List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+    // search
+    Integer SEARCH_K = 1; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name", "book_content");
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKBinaryCollection)
+            .withPartitionNames(
+                usePart
+                    ? Arrays.asList(CommonData.defaultStringPKBinaryPartition)
+                    : Arrays.asList())
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(book_intro_array)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .withExpr("book_name in [\"" + newBookNameBin + "\"]")
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(searchResultsR.getData().getStatus().getReason(), "search result is empty");
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  /* @Severity(SeverityLevel.NORMAL)
+    @Test(description = "int Pk and float vector search in partition after insert  entity")
+    public void intPKAndFloatVectorSearchByPartitionAfterInsert() throws InterruptedException {
+      // insert first
+      List<Long> book_id_array =
+          new ArrayList<Long>() {
+            {
+              add(9999L);
+            }
+          };
+      List<Long> word_count_array =
+          new ArrayList<Long>() {
+            {
+              add(19999L);
+            }
+          };
+      List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+      List<List<Float>> book_intro_array =
+          new ArrayList<List<Float>>() {
+            {
+              add(fs);
+            }
+          };
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+      fields.add(
+          new InsertParam.Field(
+              CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+      milvusClient.insert(
+          InsertParam.newBuilder()
+              .withCollectionName(CommonData.defaultCollection)
+              .withPartitionName(CommonData.defaultPartition)
+              .withFields(fields)
+              .build());
+      Thread.sleep(2000);
+
+      Integer SEARCH_K = 1; // TopK
+      String SEARCH_PARAM = "{\"nprobe\":10}";
+      List<String> search_output_fields = Arrays.asList("book_id","word_count");
+      SearchParam searchParam =
+          SearchParam.newBuilder()
+              .withCollectionName(CommonData.defaultCollection)
+              .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+              .withMetricType(MetricType.L2)
+              .withOutFields(search_output_fields)
+              .withTopK(SEARCH_K)
+              .withVectors(book_intro_array)
+              .withVectorFieldName(CommonData.defaultVectorField)
+              .withParams(SEARCH_PARAM)
+              .build();
+      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+              new SearchResultsWrapper(searchResultsR.getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id",0).get(0),9999L);
+      System.out.println(searchResultsR.getData().getResults());
+    }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "int PK and binary vector search after insert the entity")
+    public void intPKAndBinaryVectorSearchByPartitionAfterInsertNewEntity() throws InterruptedException {
+      // insert entity first
+      List<Long> book_id_array =
+              new ArrayList<Long>() {
+                {
+                  add(9999L);
+                }
+              };
+      List<Long> word_count_array =
+              new ArrayList<Long>() {
+                {
+                  add(19999L);
+                }
+              };
+      List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+      fields.add(
+              new InsertParam.Field(
+                      CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+      milvusClient.insert(
+              InsertParam.newBuilder()
+                      .withCollectionName(CommonData.defaultBinaryCollection)
+                      .withPartitionName(CommonData.defaultBinaryPartition)
+                      .withFields(fields)
+                      .build());
+      Thread.sleep(2000);
+      // search
+      Integer SEARCH_K = 1; // TopK
+      String SEARCH_PARAM = "{\"nprobe\":10}";
+      List<String> search_output_fields = Arrays.asList("book_id","word_count");
+
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(CommonData.defaultBinaryCollection)
+                      .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
+                      .withMetricType(MetricType.JACCARD)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(book_intro_array)
+                      .withVectorFieldName(CommonData.defaultBinaryVectorField)
+                      .withParams(SEARCH_PARAM)
+                      .build();
+      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+              new SearchResultsWrapper(searchResultsR.getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
+      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id",0).get(0),9999L);
+      System.out.println(searchResultsR.getData().getResults());
+    }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "int PK and float vector search after update the entity")
+    public void intPKAndFloatVectorSearchByPartitionAfterUpdateEntity() throws InterruptedException {
+      Random random = new Random();
+      int id = random.nextInt(2000);
+      // update entity first
+      List<Long> book_id_array =
+              new ArrayList<Long>() {
+                {
+                  add((long) id);
+                }
+              };
+      List<Long> word_count_array =
+              new ArrayList<Long>() {
+                {
+                  add(19999L);
+                }
+              };
+      List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
+      List<List<Float>> book_intro_array =
+              new ArrayList<List<Float>>() {
+                {
+                  add(fs);
+                }
+              };
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+      fields.add(
+              new InsertParam.Field(
+                      CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+      milvusClient.insert(
+              InsertParam.newBuilder()
+                      .withCollectionName(CommonData.defaultCollection)
+                      .withPartitionName(CommonData.defaultPartition)
+                      .withFields(fields)
+                      .build());
+      Thread.sleep(2000);
+      // search
+      Integer SEARCH_K = 1; // TopK
+      String SEARCH_PARAM = "{\"nprobe\":10}";
+      List<String> search_output_fields = Arrays.asList("book_id","word_count");
+
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(CommonData.defaultCollection)
+                      .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+                      .withMetricType(MetricType.L2)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(book_intro_array)
+                      .withVectorFieldName(CommonData.defaultVectorField)
+                      .withParams(SEARCH_PARAM)
+                      .build();
+      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+              new SearchResultsWrapper(searchResultsR.getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
+      System.out.println(searchResultsR.getData().getResults());
+    }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "int PK and binary vector search after update the entity")
+    public void intPKAndBinaryVectorSearchByPartitionAfterUpdateEntity() throws InterruptedException {
+      Random random = new Random();
+      int id = random.nextInt(2000);
+      // update entity first
+      List<Long> book_id_array =
+              new ArrayList<Long>() {
+                {
+                  add((long) id);
+                }
+              };
+      List<Long> word_count_array =
+              new ArrayList<Long>() {
+                {
+                  add(19999L);
+                }
+              };
+      List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
+
+      List<InsertParam.Field> fields = new ArrayList<>();
+      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
+      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+      fields.add(
+              new InsertParam.Field(
+                      CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
+      milvusClient.insert(
+              InsertParam.newBuilder()
+                      .withCollectionName(CommonData.defaultBinaryCollection)
+                      .withPartitionName(CommonData.defaultBinaryPartition)
+                      .withFields(fields)
+                      .build());
+      Thread.sleep(2000);
+      // search
+      Integer SEARCH_K = 1; // TopK
+      String SEARCH_PARAM = "{\"nprobe\":10}";
+      List<String> search_output_fields = Arrays.asList("book_id","word_count");
+
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(CommonData.defaultBinaryCollection)
+                      .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
+                      .withMetricType(MetricType.JACCARD)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(book_intro_array)
+                      .withVectorFieldName(CommonData.defaultBinaryVectorField)
+                      .withParams(SEARCH_PARAM)
+                      .build();
+      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+      SearchResultsWrapper searchResultsWrapper =
+              new SearchResultsWrapper(searchResultsR.getData().getResults());
+      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
+      System.out.println(searchResultsR.getData().getResults());
+    }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "int PK and float vector search after delete data")
+    public void intPKAndFloatVectorSearchByPartitionAfterDelete() throws InterruptedException {
+      R<MutationResult> mutationResultR =
+              milvusClient.delete(
+                      DeleteParam.newBuilder()
+                              .withCollectionName(CommonData.defaultCollection)
+                              .withPartitionName(CommonData.defaultPartition)
+                              .withExpr("book_id in [1,2,3]")
+                              .build());
+      Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+      Thread.sleep(2000);
+      Integer SEARCH_K = 2; // TopK
+      String SEARCH_PARAM = "{\"nprobe\":10}";
+      List<String> search_output_fields = Arrays.asList("book_id");
+      List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(CommonData.defaultCollection)
+                      .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+                      .withMetricType(MetricType.L2)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(search_vectors)
+                      .withVectorFieldName(CommonData.defaultVectorField)
+                      .withParams(SEARCH_PARAM)
+                      .withExpr(" book_id in [1,2,3] ")
+                      .build();
+      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+      System.out.println(searchResultsR.getData().getResults());
+      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+      Assert.assertEquals(searchResultsR.getData().getResults().getFieldsDataCount(), 0);
+    }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "int PK and binary vector search after delete data")
+    public void intPKAndBinaryVectorSearchByPartitionAfterDelete() throws InterruptedException {
+      R<MutationResult> mutationResultR =
+              milvusClient.delete(
+                      DeleteParam.newBuilder()
+                              .withCollectionName(CommonData.defaultBinaryCollection)
+                              .withPartitionName(CommonData.defaultBinaryPartition)
+                              .withExpr("book_id in [1,2,3]")
+                              .build());
+      Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
+      Thread.sleep(2000);
+      Integer SEARCH_K = 2; // TopK
+      String SEARCH_PARAM = "{\"nprobe\":10}";
+      List<String> search_output_fields = Arrays.asList("book_id");
+      List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+      SearchParam searchParam =
+              SearchParam.newBuilder()
+                      .withCollectionName(CommonData.defaultBinaryCollection)
+                      .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
+                      .withMetricType(MetricType.JACCARD)
+                      .withOutFields(search_output_fields)
+                      .withTopK(SEARCH_K)
+                      .withVectors(search_vectors)
+                      .withVectorFieldName(CommonData.defaultBinaryVectorField)
+                      .withParams(SEARCH_PARAM)
+                      .withExpr(" book_id in [1,2,3] ")
+                      .build();
+      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+      System.out.println(searchResultsR.getData().getResults());
+      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+      Assert.assertEquals(searchResultsR.getData().getResults().getFieldsDataCount(), 0);
+    }
+  */
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "int PK and float vector search by alias")
+  public void intPKAndFloatVectorSearchByAlias() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultAlias)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
+    Assert.assertEquals(
+        searchResultsR.getData().getResults().getIds().getIntId().getDataCount(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "int PK and float vector search by alias")
+  public void intPKAndFloatVectorSearchByNonexistentAlias() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName("NonexistentAlias")
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertEquals(
+        searchResultsR.getException().getMessage(),
+        "DescribeCollection failed: can't find collection: NonexistentAlias");
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "int pk and binary vector search by alias")
+  public void intPKAndBinaryVectorSearchByAlias() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultBinaryAlias)
+            .withMetricType(MetricType.JACCARD)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    System.out.println(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
+    Assert.assertEquals(
+        searchResultsR.getData().getResults().getIds().getIntId().getDataCount(), 2);
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "search with each consistency level", dataProvider = "providerConsistency")
+  public void intPKSearchWithConsistencyLevel(ConsistencyLevelEnum consistencyLevel) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withConsistencyLevel(consistencyLevel)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "String Pk and  float vector search with consistency",
+      dataProvider = "providerConsistency")
+  public void stringPKSearchWithConsistencyLevel(ConsistencyLevelEnum consistencyLevel) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(CommonData.defaultStringPKCollection)
+            .withMetricType(MetricType.L2)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .withConsistencyLevel(consistencyLevel)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Int PK and float vector search with each index", dataProvider = "FloatIndex")
+  public void intPKAndFloatVectorSearchWithEachIndex(IndexType indexType, MetricType metricType) {
+    String newCollection = CommonFunction.createNewCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(newCollection)
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                    .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateData(1000);
+    milvusClient.insert(
+        InsertParam.newBuilder().withCollectionName(newCollection).withFields(fields).build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // search
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(newCollection)
+            .withMetricType(metricType)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_id", 0).size(), 2);
+    System.out.println(searchResultsR.getData().getResults());
+    // drop collection
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+      description = "String PK and Binary vector search with each index",
+      dataProvider = "BinaryIndex")
+  public void stringPKAndBinaryVectorSearchWithEachIndex(
+      IndexType indexType, MetricType metricType) {
+    boolean b = metricType.equals(MetricType.SUBSTRUCTURE) || metricType.equals(MetricType.SUPERSTRUCTURE);
+
+    if(indexType.equals(IndexType.BIN_IVF_FLAT)&& b){
+      return;
+    }
+    String stringPKAndBinaryCollection = CommonFunction.createStringPKAndBinaryCollection();
+    // create index
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(stringPKAndBinaryCollection)
+                .withFieldName(CommonData.defaultBinaryVectorField)
+                .withIndexName(CommonData.defaultBinaryIndex)
+                .withMetricType(metricType)
+                .withIndexType(indexType)
+                .withExtraParam(CommonData.defaultExtraParam)
+                .withSyncMode(Boolean.FALSE)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    // Insert test data
+    List<InsertParam.Field> fields = CommonFunction.generateStringPKBinaryData(2000);
+    milvusClient.insert(
+        InsertParam.newBuilder()
+            .withFields(fields)
+            .withCollectionName(stringPKAndBinaryCollection)
+            .build());
+    // load
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder()
+            .withCollectionName(stringPKAndBinaryCollection)
+            .withSyncLoad(true)
+            .withSyncLoadWaitingInterval(500L)
+            .withSyncLoadWaitingTimeout(30L)
+            .build());
+    // search
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
+
+    SearchParam searchParam =
+        SearchParam.newBuilder()
+            .withCollectionName(stringPKAndBinaryCollection)
+            .withMetricType(metricType)
+            .withOutFields(search_output_fields)
+            .withTopK(SEARCH_K)
+            .withVectors(search_vectors)
+            .withVectorFieldName(CommonData.defaultBinaryVectorField)
+            .withParams(SEARCH_PARAM)
+            .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    System.out.println(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    if (b){
+      return ;
+    }
+    SearchResultsWrapper searchResultsWrapper =
+        new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertEquals(searchResultsWrapper.getFieldData("book_name", 0).size(), 2);
+    // drop collection
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(stringPKAndBinaryCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Int PK search with each expression", dataProvider = "provideIntExpressions")
+  public void intPKSearchWithEachExpressions(String express) {
+    Integer SEARCH_K = 4; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withMetricType(MetricType.L2)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .withExpr(express)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+            new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertTrue(searchResultsWrapper.getFieldData("book_id",0).size() >= 1);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(
+          description = "string PK Search with each expressions",
+          dataProvider = "provideStringExpressions")
+  public void stringPKSearchWithEachExpressions(String expression) {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withMetricType(MetricType.L2)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .withExpr(expression)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
+    SearchResultsWrapper searchResultsWrapper =
+            new SearchResultsWrapper(searchResultsR.getData().getResults());
+    Assert.assertTrue(searchResultsWrapper.getFieldData("book_name", 0).size()>=1);
+    System.out.println(searchResultsR.getData().getResults());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/segment/GetPersistentSegmentInfoTest.java

@@ -0,0 +1,45 @@
+package com.zilliz.milvustest.segment;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.GetPersistentSegmentInfoResponse;
+import io.milvus.grpc.SegmentState;
+import io.milvus.param.R;
+import io.milvus.param.collection.FlushParam;
+import io.milvus.param.control.GetPersistentSegmentInfoParam;
+import io.qameta.allure.Epic;
+import io.qameta.allure.Feature;
+import io.qameta.allure.Severity;
+import io.qameta.allure.SeverityLevel;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+
+@Epic("Segment")
+@Feature("GetPersistentSegmentInfo")
+public class GetPersistentSegmentInfoTest extends BaseTest {
+  @BeforeClass
+  public void flushFirst() {
+    milvusClient.flush(
+        FlushParam.newBuilder()
+            .withCollectionNames(Arrays.asList(CommonData.defaultCollection))
+            .build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description =
+          "Gets the information of persistent segments from data node, including row count, persistence state")
+  public void getPersistentSegmentInfoTest() {
+    R<GetPersistentSegmentInfoResponse> responseR =
+        milvusClient.getPersistentSegmentInfo(
+            GetPersistentSegmentInfoParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    Assert.assertEquals(responseR.getStatus().intValue(), 0);
+    Assert.assertEquals(responseR.getData().getInfos(0).getState(), SegmentState.Flushed);
+    System.out.println(responseR.getData());
+  }
+}

tests/milvustest/src/test/java/com/zilliz/milvustest/segment/GetQuerySegmentInfoTest.java

@@ -0,0 +1,38 @@
+package com.zilliz.milvustest.segment;
+
+import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
+import io.milvus.grpc.GetQuerySegmentInfoResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.control.GetQuerySegmentInfoParam;
+import io.qameta.allure.*;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.Test;
+
+@Epic("Segment")
+@Feature("GetQuerySegmentInfo")
+public class GetQuerySegmentInfoTest extends BaseTest {
+  @AfterClass
+  public void LoadFirst() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Issue("https://github.com/milvus-io/milvus-sdk-java/issues/322")
+  @Test(
+      description =
+          "Gets the query information of segments in a collection from query node, including row count,")
+  public void getQuerySegmentInfoTest() {
+    R<GetQuerySegmentInfoResponse> responseR =
+        milvusClient.getQuerySegmentInfo(
+            GetQuerySegmentInfoParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    System.out.println(responseR.getData());
+    Assert.assertEquals(responseR.getStatus().intValue(), 0);
+    Assert.assertEquals(responseR.getData().getInfos(0), 0);
+  }
+}

tests/milvustest/src/test/java/resources/run.properties

@@ -0,0 +1,11 @@
+milvusHost=10.98.0.8
+milvusPort=19530
+#enviroment
+milvusV=2.1.0
+milvusJdkJavaV=2.1.0
+#minio
+minioHost=http://10.97.13.196:9000
+accesskey=minioadmin
+secretkey=minioadmin
+
+

tests/milvustest/testng.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
+<suite name="Milvus Java SDK test Suite" parallel="classes" thread-count="3">
+    <!--folder-->
+    <test name="connection">
+        <packages>
+            <package name="com.zilliz.milvustest.connection" />
+        </packages>
+    </test>
+    <test name="collection">
+        <packages>
+            <package name="com.zilliz.milvustest.collection" />
+        </packages>
+    </test>
+</suite>

tests/milvustest/testngAll.xml

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
+<suite name="Milvus Java SDK test Suite" parallel="classes" thread-count="1">
+    <!--folder-->
+    <test name="connection">
+        <packages>
+            <package name="com.zilliz.milvustest.connection" />
+        </packages>
+    </test>
+    <test name="collection">
+        <packages>
+            <package name="com.zilliz.milvustest.collection" />
+        </packages>
+     </test>
+    <test name="partition">
+        <packages>
+            <package name="com.zilliz.milvustest.partition" />
+        </packages>
+    </test>
+    <test name="Alias">
+        <packages>
+            <package name="com.zilliz.milvustest.alias" />
+        </packages>
+    </test>
+    <test name="index">
+        <packages>
+            <package name="com.zilliz.milvustest.index" />
+        </packages>
+    </test>
+    <test name="insert">
+        <packages>
+            <package name="com.zilliz.milvustest.insert" />
+        </packages>
+    </test>
+    <test name="load">
+        <packages>
+            <package name="com.zilliz.milvustest.load" />
+        </packages>
+    </test>
+    <test name="query">
+        <packages>
+            <package name="com.zilliz.milvustest.query" />
+        </packages>
+    </test>
+    <test name="search">
+        <packages>
+            <package name="com.zilliz.milvustest.search" />
+        </packages>
+    </test>
+    <test name="credential">
+        <packages>
+            <package name="com.zilliz.milvustest.credential" />
+        </packages>
+    </test>
+    <test name="other">
+        <packages>
+            <package name="com.zilliz.milvustest.other" />
+        </packages>
+    </test>
+    <test name="flush">
+        <packages>
+            <package name="com.zilliz.milvustest.flush" />
+        </packages>
+    </test>
+    <test name="compaction">
+        <packages>
+            <package name="com.zilliz.milvustest.compaction" />
+        </packages>
+    </test>
+    <test name="segment">
+        <packages>
+            <package name="com.zilliz.milvustest.segment" />
+        </packages>
+    </test>
+    <test name="businessflow">
+        <packages>
+            <package name="com.zilliz.milvustest.businessflow" />
+        </packages>
+    </test>
+
+    <!--
+    &lt;!&ndash;class&ndash;&gt;
+    <test name="collection test">
+         <classes>
+             <class name="com.zilliz.milvustest.collection.ShowCollectionsTest"/>
+             <class name="com.zilliz.milvustest.collection.HasCollectionTest"/>
+         </classes>
+     </test>
+     &lt;!&ndash;method&ndash;&gt;
+     <test name="collection test">
+         <classes>
+             <class name="com.zilliz.milvustest.collection.ShowCollectionsTest">
+                 <methods>
+                     <include name="showCollectionTest1"/>
+                 </methods>
+             </class>
+         </classes>
+     </test>-->
+    <listeners>
+        <listener class-name="com.zilliz.milvustest.service.ComstumerListener"/>
+    </listeners>
+</suite>