add testcases for partition and so on . (#348)

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

tests/milvustest/.gitignore

@@ -4,6 +4,8 @@ target/
 !**/src/main/**/target/
 !**/src/test/**/target/
 */.DS_Store
+logs/
+allure-results/
 ### STS ###
 .apt_generated
 .classpath

tests/milvustest/pom.xml

@@ -6,7 +6,7 @@
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.6.7</version>
-        <relativePath/> <!-- lookup parent from repository -->
+        <relativePath/>
     </parent>
     <groupId>com.zilliz</groupId>
     <artifactId>milvustest</artifactId>
@@ -18,8 +18,8 @@
         <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框架-->
+        <!--TestNg Aullre Report Use-->
+        <aspectj.version>1.9.2</aspectj.version>
         <allure.version>2.13.2</allure.version>
         <xmlFileName>testng.xml</xmlFileName>
     </properties>
@@ -59,7 +59,6 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-test</artifactId>
         </dependency>
-        <!-- Jackson序列化和反序列化 -->
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
@@ -80,14 +79,13 @@
             <artifactId>milvus-sdk-java</artifactId>
             <version>2.1.0-beta3</version>
         </dependency>
-        <!--Allure报告依赖包-->
+        <!--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>
@@ -134,23 +132,20 @@
                     <argLine>
                         -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
                     </argLine>
-                    <!--生成allure-result的目录-->
+                    <!--generate 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>
-                    <!--测试失败后，是否忽略并继续测试-->
+                    <!--ignore test failure-->
                     <testFailureIgnore>true</testFailureIgnore>
                     <argLine>
                         -Dfile.encoding=UTF-8
                     </argLine>
                     <suiteXmlFiles>
-                        <!--该文件位于工程根目录时，直接填写名字，其它位置要加上路径-->
                         <suiteXmlFile>${xmlFileName}</suiteXmlFile>
                     </suiteXmlFiles>
                 </configuration>

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

@@ -334,7 +334,7 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
                     .build());
 
     logger.info("insert data");
-    List<InsertParam.Field> fields = CommonFunction.generateStringData();
+    List<InsertParam.Field> fields = CommonFunction.generateStringData(2000);
     milvusClient.insert(
             InsertParam.newBuilder()
                     .withCollectionName(CommonData.defaultStringPKCollection)

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

@@ -55,6 +55,36 @@ public class CommonFunction {
     logger.info("create collection:" + collectionName);
     return collectionName;
   }
+  public static String createNewCollectionWithAutoPK() {
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+            FieldType.newBuilder()
+                    .withName("book_id")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(true)
+                    .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() {
@@ -229,6 +259,26 @@ public class CommonFunction {
     // logger.info("generateTestData"+ JacksonUtil.serialize(fields));
     return fields;
   }
+  public static List<InsertParam.Field> generateDataWithAutoPK(int num) {
+    Random ran = new Random();
+    List<Long> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < num; ++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("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(
@@ -304,12 +354,12 @@ public class CommonFunction {
     return vectors;
   }
 
-  public static List<InsertParam.Field> generateStringData() {
+  public static List<InsertParam.Field> generateStringData(int num) {
     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) {
+    for (long i = 0L; i < num; ++i) {
       book_name_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
       book_content_array.add(i + "-" + MathUtil.genRandomStringAndChinese(10));
       List<Float> vector = new ArrayList<>();

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

@@ -4,21 +4,26 @@ 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.DescribeCollectionResponse;
 import io.milvus.grpc.QueryResults;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.MetricType;
 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.DescribeCollectionParam;
 import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.HasCollectionParam;
 import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.dml.QueryParam;
-import io.milvus.response.QueryResultsWrapper;
+import io.milvus.param.dml.SearchParam;
+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 lombok.NonNull;
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
@@ -62,25 +67,81 @@ public class AlterAliasTest extends BaseTest {
                 .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());
+  @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();
+        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"));
+    Assert.assertTrue(
+        queryResultsR.getException().getMessage().contains("checkIfLoaded failed when query"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search after Alter alias", dependsOnMethods = "alterAliasTest")
+  public void searchAfterAlterAlias() {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    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(aliasStr)
+            .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().getStatus().getReason(), "search result is empty");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "hasCollection after alter alias", dependsOnMethods = "alterAliasTest")
+  public void hasCollectionAfterAlterAlias() {
+    R<Boolean> booleanR =
+        milvusClient.hasCollection(
+            HasCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    Assert.assertEquals(booleanR.getStatus().intValue(), 0);
+    Assert.assertTrue(booleanR.getData());
+  }
 
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Describe Collection after alter alias", dependsOnMethods = "alterAliasTest")
+  public void describeCollectionAfterAlterAlias() {
+    R<DescribeCollectionResponse> describeCollectionResponseR =
+        milvusClient.describeCollection(
+            DescribeCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    Assert.assertEquals(describeCollectionResponseR.getStatus().intValue(), 0);
+    DescCollResponseWrapper descCollResponseWrapper =
+        new DescCollResponseWrapper(describeCollectionResponseR.getData());
+    Assert.assertEquals(descCollResponseWrapper.getCollectionName(), collectionStr);
   }
 
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Drop Collection use alias", dependsOnMethods = "alterAliasTest")
+  public void dropCollectionUseAlias() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        rpcStatusR.getException().getMessage().contains("cannot drop the collection via alias"));
+  }
 }

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

@@ -4,27 +4,27 @@ 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.grpc.SearchResults;
+import io.milvus.param.MetricType;
 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.milvus.response.SearchResultsWrapper;
 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.DataProvider;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
@@ -32,15 +32,37 @@ import java.util.List;
 @Feature("CreateAlias")
 public class CreateAliasTest extends BaseTest {
   private String aliasStr;
+  private String anotherAliasStr;
 
   @BeforeClass
   public void initData() {
     aliasStr = "alias_" + MathUtil.getRandomString(10);
+    anotherAliasStr = "alias_" + MathUtil.getRandomString(10);
   }
 
   @AfterClass
   public void dropAlias() {
     milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(aliasStr).build());
+    milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias(anotherAliasStr).build());
+  }
+
+  @DataProvider(name = "provideAlias")
+  public Object[][] provideAlias() {
+    return new Object[][] {{aliasStr}, {anotherAliasStr}};
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Create alias for collection")
+  public void createAliasWithNonexistentCollection() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createAlias(
+            CreateAliasParam.newBuilder()
+                .withCollectionName("NonexistentCollection")
+                .withAlias("alias"+MathUtil.getRandomString(10))
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        rpcStatusR.getException().getMessage().contains("aliased collection name does not exist"));
   }
 
   @Severity(SeverityLevel.BLOCKER)
@@ -57,17 +79,21 @@ public class CreateAliasTest extends BaseTest {
   }
 
   @Severity(SeverityLevel.CRITICAL)
-  @Test(description = "query collection with alias",dependsOnMethods = "createAliasTest")
-  public void queryWithAlias() {
-    milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+  @Test(
+      description = "query collection with alias",
+      dependsOnMethods = {"createAliasTest", "createAnotherAliasTest"},
+      dataProvider = "provideAlias")
+  public void queryWithAlias(String alias) {
+    milvusClient.loadCollection(
+        LoadCollectionParam.newBuilder().withCollectionName(alias).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();
+        QueryParam.newBuilder()
+            .withCollectionName(alias)
+            .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());
@@ -75,7 +101,48 @@ public class CreateAliasTest extends BaseTest {
     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.CRITICAL)
+  @Test(description = "Create another alias for collection")
+  public void createAnotherAliasTest() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createAlias(
+            CreateAliasParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withAlias(anotherAliasStr)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
   }
 
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+          description = "search with alias",
+          dependsOnMethods = {"createAliasTest", "createAnotherAliasTest"},
+          dataProvider = "provideAlias")
+  public void searchWithAlias(String alias) {
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder().withCollectionName(alias).build());
+    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(alias)
+                    .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(), SEARCH_K.intValue());
+    System.out.println(searchResultsR.getData().getResults());
+  }
 }

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

@@ -3,13 +3,20 @@ 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.DescribeCollectionResponse;
 import io.milvus.grpc.QueryResults;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.MetricType;
 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.HasCollectionParam;
 import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.response.DescCollResponseWrapper;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -63,4 +70,58 @@ public class DropAliasTest extends BaseTest {
     Assert.assertEquals(
         queryResultsR.getException().getMessage(),"DescribeCollection failed: can't find collection: "+aliasStr);
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "drop nonexistent alias")
+  public void dropNonexistentAlias() {
+    R<RpcStatus> rpcStatusR =
+            milvusClient.dropAlias(DropAliasParam.newBuilder().withAlias("NonexistentAlias").build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(rpcStatusR.getException().getMessage().contains("alias does not exist"));
+  }
+
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search after drop alias", dependsOnMethods = "dropAlias")
+  public void searchAfterDropAlias() {
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    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(aliasStr)
+                    .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: "+aliasStr);
+  }
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "hasCollection after drop alias", dependsOnMethods = "dropAlias")
+  public void hasCollectionAfterDropAlias() {
+    R<Boolean> booleanR =
+            milvusClient.hasCollection(
+                    HasCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    Assert.assertEquals(booleanR.getStatus().intValue(), 0);
+    Assert.assertFalse(booleanR.getData());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Describe Collection after drop alias", dependsOnMethods = "dropAlias")
+  public void describeCollectionAfterDropAlias() {
+    R<DescribeCollectionResponse> describeCollectionResponseR =
+            milvusClient.describeCollection(
+                    DescribeCollectionParam.newBuilder().withCollectionName(aliasStr).build());
+    Assert.assertEquals(describeCollectionResponseR.getStatus().intValue(), 1);
+    Assert.assertTrue(describeCollectionResponseR.getException().getMessage().contains("can't find collection"));
+  }
 }

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

@@ -47,6 +47,35 @@ public class CreateCollectionTest extends BaseTest {
     }
   }
 
+  @DataProvider(name = "dataTypeProvider")
+  public Object[][] provideDataType() {
+    Object[][] pk = new Object[][] {{DataType.Int64}, {DataType.VarChar}};
+    Object[][] filedType =
+        new Object[][] {
+          {DataType.Double},
+          {DataType.Float},
+          {DataType.Int64},
+          {DataType.Int8},
+          {DataType.Int16},
+          {DataType.Int32},
+          {DataType.VarChar}
+        };
+    Object[][] vectorType = new Object[][] {{DataType.FloatVector}, {DataType.BinaryVector}};
+    Object[][] dataType = new Object[pk.length * filedType.length * vectorType.length][3];
+    int a = 0;
+    for (int i = 0; i < pk.length; i++) {
+      for (int j = 0; j < filedType.length; j++) {
+        for (int k = 0; k < vectorType.length; k++) {
+          dataType[a][0] = pk[i][0];
+          dataType[a][1] = filedType[j][0];
+          dataType[a][2] = vectorType[k][0];
+          a++;
+        }
+      }
+    }
+    return dataType;
+  }
+
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "Create collection success", dataProvider = "collectionByDataProvider")
   public void createCollectionSuccess(String collectionName) {
@@ -198,37 +227,81 @@ public class CreateCollectionTest extends BaseTest {
   }
 
   @Severity(SeverityLevel.NORMAL)
-  @Test(description = "Create String collection without max length", dataProvider = "collectionByDataProvider", expectedExceptions = ParamException.class)
+  @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.newBuilder()
+            .withName("book_name")
+            .withDataType(DataType.VarChar)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .build();
     FieldType fieldType2 =
-            FieldType.newBuilder()
-                    .withName("book_content")
-                    .withDataType(DataType.VarChar)
-                    .build();
+        FieldType.newBuilder().withName("book_content").withDataType(DataType.VarChar).build();
     FieldType fieldType3 =
-            FieldType.newBuilder()
-                    .withName("book_intro")
-                    .withDataType(DataType.FloatVector)
-                    .withDimension(128)
-                    .build();
+        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();
+        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");
+    Assert.assertEquals(
+        collection.getData().getMsg(), "Varchar field max length must be specified");
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(
+      description = "Float vector collection using each data type",
+      dataProvider = "dataTypeProvider")
+  public void createCollectionWithEachDataType(
+      DataType pk, DataType fieldType, DataType vectorType) {
+    String collectionName = "coll" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+        FieldType.newBuilder()
+            .withName("book_id")
+            .withDataType(pk)
+            .withPrimaryKey(true)
+            .withAutoID(false)
+            .withMaxLength(10)
+            .build();
+    FieldType fieldType2 =
+        FieldType.newBuilder()
+            .withName("word_count")
+            .withDataType(fieldType)
+            .withMaxLength(10)
+            .build();
+    FieldType fieldType3 =
+        FieldType.newBuilder()
+            .withName("book_intro")
+            .withDataType(vectorType)
+            .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");
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
   }
 }

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

@@ -11,19 +11,30 @@ 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("Collection")
 @Feature("DescribeCollection")
 public class DescribeCollectionTest extends BaseTest {
 
+  @DataProvider(name = "provideCollection")
+  public Object[][] provideCollection() {
+    return new Object[][] {
+      {CommonData.defaultCollection},
+      {CommonData.defaultStringPKCollection},
+      {CommonData.defaultBinaryCollection},
+      {CommonData.defaultStringPKBinaryCollection}
+    };
+  }
+
   @Severity(SeverityLevel.BLOCKER)
-  @Test(description = "query the name and schema of the collection")
-  public void describeCollectionTest() {
+  @Test(description = "query the name and schema of the collection",dataProvider = "provideCollection")
+  public void describeCollection(String collection) {
     R<DescribeCollectionResponse> respDescribeCollection =
         milvusClient.describeCollection( // Return the name and schema of the collection.
             DescribeCollectionParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
+                .withCollectionName(collection)
                 .build());
     System.out.println(respDescribeCollection);
     Assert.assertEquals(respDescribeCollection.getStatus().intValue(), 0);
@@ -31,7 +42,22 @@ public class DescribeCollectionTest extends BaseTest {
     DescCollResponseWrapper descCollResponseWrapper =
         new DescCollResponseWrapper(respDescribeCollectionData);
     System.out.println(descCollResponseWrapper);
-    Assert.assertEquals(descCollResponseWrapper.getCollectionName(), CommonData.defaultCollection);
+    Assert.assertEquals(descCollResponseWrapper.getCollectionName(), collection);
     Assert.assertEquals(descCollResponseWrapper.getFields().size(), 3);
+    Assert.assertEquals(descCollResponseWrapper.getShardNumber(),2);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Describe nonexistent collection")
+  public void describeNonexistentCollection() {
+    R<DescribeCollectionResponse> respDescribeCollection =
+            milvusClient.describeCollection( // Return the name and schema of the collection.
+                    DescribeCollectionParam.newBuilder()
+                            .withCollectionName("NonexistentCollection")
+                            .build());
+    System.out.println(respDescribeCollection);
+    Assert.assertEquals(respDescribeCollection.getStatus().intValue(), 1);
+    Assert.assertTrue(respDescribeCollection.getException().getMessage().contains("can't find collection"));
+
   }
 }

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

@@ -1,11 +1,21 @@
 package com.zilliz.milvustest.collection;
 
 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.DescribeCollectionResponse;
+import io.milvus.grpc.QueryResults;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.MetricType;
 import io.milvus.param.R;
 import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DescribeCollectionParam;
 import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.HasCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -14,6 +24,9 @@ import org.testng.Assert;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.Arrays;
+import java.util.List;
+
 @Epic("Collection")
 @Feature("DropCollection")
 public class DropCollectionTest extends BaseTest {
@@ -27,13 +40,12 @@ public class DropCollectionTest extends BaseTest {
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "drop collection")
-  public void dropCollectionSuccess() {
+  public void dropCollection() {
     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)
@@ -48,4 +60,66 @@ public class DropCollectionTest extends BaseTest {
         rpcStatusR.getException().getMessage(),
         "DescribeCollection failed: can't find collection: " + collection + "");
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "query after drop collection", dependsOnMethods = "dropCollection")
+  public void queryAfterDropCollection() {
+    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(commonCollection)
+                    .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: "+commonCollection);
+  }
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search after drop collection", dependsOnMethods = "dropCollection")
+  public void searchAfterDropCollection() {
+    milvusClient.loadCollection(
+            LoadCollectionParam.newBuilder().withCollectionName(commonCollection).build());
+    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(commonCollection)
+                    .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: "+commonCollection);
+  }
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "hasCollection after drop collection", dependsOnMethods = "dropCollection")
+  public void hasCollectionAfterDropCollection() {
+    R<Boolean> booleanR =
+            milvusClient.hasCollection(
+                    HasCollectionParam.newBuilder().withCollectionName(commonCollection).build());
+    Assert.assertEquals(booleanR.getStatus().intValue(), 0);
+    Assert.assertFalse(booleanR.getData());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Describe Collection after drop alias", dependsOnMethods = "dropCollection")
+  public void describeCollectionAfterDropAlias() {
+    R<DescribeCollectionResponse> describeCollectionResponseR =
+            milvusClient.describeCollection(
+                    DescribeCollectionParam.newBuilder().withCollectionName(commonCollection).build());
+    Assert.assertEquals(describeCollectionResponseR.getStatus().intValue(), 1);
+    Assert.assertTrue(describeCollectionResponseR.getException().getMessage().contains("can't find collection"));
+  }
 }

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

@@ -34,7 +34,7 @@ public class GetCollectionStatisticsTest extends BaseTest {
     System.out.println(wrapperCollectionStatistics);
   }
 
-  @Severity(SeverityLevel.CRITICAL)
+  @Severity(SeverityLevel.BLOCKER)
   @Test(description = "Shows the statistics information of a collection with flush")
   public void getCollectionStatisticsWithFlushTest() {
     R<GetCollectionStatisticsResponse> respCollectionStatistics =
@@ -50,4 +50,19 @@ public class GetCollectionStatisticsTest extends BaseTest {
     Assert.assertEquals(wrapperCollectionStatistics.getRowCount(), 2000);
     System.out.println(wrapperCollectionStatistics);
   }
+
+  @Severity(SeverityLevel.MINOR)
+  @Test(description = "get the statistics information of nonexistent collection.")
+  public void getNonexistentCollectionStatisticsInfo() {
+    R<GetCollectionStatisticsResponse> respCollectionStatistics =
+            milvusClient
+                    .getCollectionStatistics( // Return the statistics information of the collection.
+                            GetCollectionStatisticsParam.newBuilder()
+                                    .withCollectionName("NonexistentCollection")
+                                    .withFlush(false)
+                                    .build());
+    Assert.assertEquals(respCollectionStatistics.getStatus().intValue(), 1);
+    Assert.assertTrue(respCollectionStatistics.getException().getMessage().contains("can't find collection"));
+
+  }
 }

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

@@ -2,10 +2,16 @@ 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.grpc.QueryResults;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.MetricType;
 import io.milvus.param.R;
 import io.milvus.param.RpcStatus;
 import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.dml.QueryParam;
+import io.milvus.param.dml.SearchParam;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -14,6 +20,9 @@ import org.testng.Assert;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.Arrays;
+import java.util.List;
+
 @Epic("Collection")
 @Feature("ReleaseCollection")
 public class ReleaseCollectionTest extends BaseTest {
@@ -25,7 +34,7 @@ public class ReleaseCollectionTest extends BaseTest {
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "release collection")
-  public void releaseCollectionTest() {
+  public void releaseCollection() {
     R<RpcStatus> rpcStatusR =
         milvusClient.releaseCollection(
             ReleaseCollectionParam.newBuilder()
@@ -34,4 +43,43 @@ public class ReleaseCollectionTest extends BaseTest {
     Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
     Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "query after release collection", dependsOnMethods = "releaseCollection")
+  public void queryAfterDropCollection() {
+    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.defaultCollection)
+                    .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"));
+  }
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "search after drop collection", dependsOnMethods = "releaseCollection")
+  public void searchAfterDropCollection() {
+    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)
+                    .withParams(SEARCH_PARAM)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+            searchResultsR.getException().getMessage().contains("checkIfLoaded failed when search"));
+  }
 }

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

@@ -8,10 +8,7 @@ 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 io.qameta.allure.*;
 import org.testng.Assert;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
@@ -32,7 +29,7 @@ public class GetCompactionStateTest extends BaseTest {
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "Gets the compaction state by id.", dataProvider = "provideCompaction")
-  public void getCompactionStateTest(long compactionId) {
+  public void getCompactionState(long compactionId) {
     R<GetCompactionStateResponse> responseR =
         milvusClient.getCompactionState(
             GetCompactionStateParam.newBuilder().withCompactionID(compactionId).build());
@@ -40,4 +37,16 @@ public class GetCompactionStateTest extends BaseTest {
     GetCompactionStateResponse data = responseR.getData();
     Assert.assertEquals(data.getState(), CompactionState.Completed);
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Gets the compaction state by nonexistent id.")
+  @Issue("nonexistent id return success ?")
+  public void getCompactionStateWithNonexistentId() {
+    R<GetCompactionStateResponse> responseR =
+            milvusClient.getCompactionState(
+                    GetCompactionStateParam.newBuilder().withCompactionID(1L).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/ManualCompactionTest.java

@@ -13,6 +13,7 @@ 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.DeleteParam;
 import io.milvus.param.dml.InsertParam;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
@@ -58,7 +59,7 @@ public class ManualCompactionTest extends BaseTest {
     R<ManualCompactionResponse> responseR =
         milvusClient.manualCompact(
             ManualCompactParam.newBuilder()
-                .withCollectionName(CommonData.defaultCollection)
+                .withCollectionName(collection)
                 .build());
     Assert.assertEquals(responseR.getStatus().intValue(), 0);
     Assert.assertTrue(responseR.getData().getCompactionID() > 0);
@@ -67,11 +68,51 @@ public class ManualCompactionTest extends BaseTest {
             milvusClient.getCompactionState(
                     GetCompactionStateParam.newBuilder().withCompactionID(compactionID).build());
     Assert.assertEquals(GetCompactionStateResponse.getStatus().intValue(), 0);
-    Assert.assertEquals(GetCompactionStateResponse.getData().getState(), CompactionState.Completed);
+    Assert.assertEquals(GetCompactionStateResponse.getData().getState(), CompactionState.Executing);
     R<GetCompactionPlansResponse> GetCompactionPlansResponse =
             milvusClient.getCompactionStateWithPlans(
                     GetCompactionPlansParam.newBuilder().withCompactionID(compactionID).build());
     Assert.assertEquals(GetCompactionPlansResponse.getStatus().intValue(), 0);
-    Assert.assertEquals(GetCompactionPlansResponse.getData().getState(),CompactionState.Completed);
+    Assert.assertEquals(GetCompactionPlansResponse.getData().getState(),CompactionState.Executing);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "manual compaction with nonexistent collection")
+  public void manualCompactionWithNonexistentCollection(){
+    R<ManualCompactionResponse> responseR =
+            milvusClient.manualCompact(
+                    ManualCompactParam.newBuilder()
+                            .withCollectionName("NonexistentCollection")
+                            .build());
+    Assert.assertEquals(responseR.getStatus().intValue(), 1);
+    Assert.assertTrue(responseR.getException().getMessage().contains("can't find collection"));
+  }
+
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "performs a manual compaction with data delete")
+  public void manualCompactionAfterDelete(){
+    milvusClient.delete(
+            DeleteParam.newBuilder()
+                    .withCollectionName(collection)
+                    .withExpr("book_id in [1,2,3]")
+                    .build());
+    R<ManualCompactionResponse> responseR =
+            milvusClient.manualCompact(
+                    ManualCompactParam.newBuilder()
+                            .withCollectionName(collection)
+                            .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.Executing);
+    R<GetCompactionPlansResponse> GetCompactionPlansResponse =
+            milvusClient.getCompactionStateWithPlans(
+                    GetCompactionPlansParam.newBuilder().withCompactionID(compactionID).build());
+    Assert.assertEquals(GetCompactionPlansResponse.getStatus().intValue(), 0);
+    Assert.assertEquals(GetCompactionPlansResponse.getData().getState(),CompactionState.Executing);
   }
 }

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

@@ -69,4 +69,16 @@ public class DeleteCredentialTest extends BaseTest {
     Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
     Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
   }
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "create credential after delete",dependsOnMethods = "deleteCredential")
+  public void createCredentialAfterDelete() {
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createCredential(
+                    CreateCredentialParam.newBuilder()
+                            .withUsername(username)
+                            .withPassword(password)
+                            .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
 }

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

@@ -78,4 +78,17 @@ public class UpdateCredentialTest extends BaseTest {
     Assert.assertEquals(rpcStatusR.getStatus().intValue(), -3);
     Assert.assertEquals(rpcStatusR.getException().getMessage(), "found no credential:nonexistent");
   }
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Update credential using illegal password")
+  public void updateCredentialWithIllegalPassword() {
+    R<RpcStatus> rpcStatusR =
+            milvusClient.updateCredential(
+                    UpdateCredentialParam.newBuilder()
+                            .withUsername(username)
+                            .withOldPassword(password)
+                            .withNewPassword("#$%^&")
+                            .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.");
+  }
 }

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

@@ -58,4 +58,23 @@ public class FlushTest extends BaseTest {
     Assert.assertEquals(flushResponseR.getStatus().intValue(), 0);
     Assert.assertTrue(flushResponseR.getData().containsCollSegIDs(CommonData.defaultCollection));
   }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "flush collection with nonexistent collection")
+    public void flushCollectionWithNonexistentCollection() {
+        List<String> collectionName =
+                new ArrayList<String>() {
+                    {
+                        add("NonexistentCollection");
+                    }
+                };
+        R<FlushResponse> flushResponseR =
+                milvusClient.flush(
+                        FlushParam.newBuilder()
+                                .withCollectionNames(collectionName)
+                                .build());
+        Assert.assertEquals(flushResponseR.getStatus().intValue(), 0);
+    Assert.assertTrue(
+        flushResponseR.getData().getStatus().getReason().contains("can\'t find collection"));
+    }
 }

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

@@ -124,7 +124,7 @@ public class CreateIndexTest extends BaseTest {
                 .withIndexName(CommonData.defaultIndex)
                 .withMetricType(metricType)
                 .withIndexType(indexType)
-                    .withExtraParam(CommonFunction.provideExtraParam(indexType))
+                .withExtraParam(CommonFunction.provideExtraParam(indexType))
                 .withSyncMode(Boolean.FALSE)
                 .build());
     System.out.println("Create index" + rpcStatusR);
@@ -141,7 +141,9 @@ public class CreateIndexTest extends BaseTest {
   @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))){
+    if (indexType.equals(IndexType.BIN_IVF_FLAT)
+        && (metricType.equals(MetricType.SUBSTRUCTURE)
+            || metricType.equals(MetricType.SUPERSTRUCTURE))) {
       return;
     }
     R<RpcStatus> rpcStatusR =
@@ -169,7 +171,9 @@ public class CreateIndexTest extends BaseTest {
   @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))){
+    if (indexType.equals(IndexType.BIN_IVF_FLAT)
+        && (metricType.equals(MetricType.SUBSTRUCTURE)
+            || metricType.equals(MetricType.SUPERSTRUCTURE))) {
       return;
     }
     R<RpcStatus> rpcStatusR =
@@ -194,4 +198,148 @@ public class CreateIndexTest extends BaseTest {
             .withIndexName(CommonData.defaultBinaryIndex)
             .build());
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Float collection create index with error metric type")
+  public void createIndexWithErrorMetricType() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(MetricType.JACCARD)
+                .withIndexType(IndexType.HNSW)
+                .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                .withSyncMode(Boolean.TRUE)
+                .withSyncWaitingTimeout(30L)
+                .withSyncWaitingInterval(500L)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(rpcStatusR.getException().getMessage().contains("invalid index params"));
+    milvusClient.dropIndex(
+        DropIndexParam.newBuilder()
+            .withCollectionName(collection)
+            .withIndexName(CommonData.defaultIndex)
+            .build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Create index with nonexistent collection")
+  public void createIndexWithNonexistentCollection() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName("NonexistentCollection")
+                .withFieldName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(MetricType.IP)
+                .withIndexType(IndexType.HNSW)
+                .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                .withSyncMode(Boolean.TRUE)
+                .withSyncWaitingTimeout(30L)
+                .withSyncWaitingInterval(500L)
+                .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(rpcStatusR.getException().getMessage().contains("can't find collection"));
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Create index with scalar field")
+  public void createIndexWithScalarField() {
+    String stringPKCollection = CommonFunction.createStringPKCollection();
+    R<RpcStatus> rpcStatusR =
+        milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                .withCollectionName(stringPKCollection)
+                .withFieldName("book_content")
+                .withIndexName(CommonData.defaultIndex)
+                .withMetricType(MetricType.IP)
+                .withIndexType(IndexType.HNSW)
+                .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                .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.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Create index with String PK")
+  public void createIndexWithStringPK() {
+    String stringPKCollection = CommonFunction.createStringPKCollection();
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(stringPKCollection)
+                            .withFieldName("book_name")
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(MetricType.IP)
+                            .withIndexType(IndexType.HNSW)
+                            .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                            .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.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+  }
+
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Create index with int PK")
+  public void createIndexWithintPK() {
+    String newCollection = CommonFunction.createNewCollection();
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(newCollection)
+                            .withFieldName("book_id")
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(MetricType.IP)
+                            .withIndexType(IndexType.HNSW)
+                            .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                            .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.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "empty collection create index")
+  public void emptyCollectionCreateIndex() {
+    String newCollection = CommonFunction.createNewCollection();
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(newCollection)
+                            .withFieldName(CommonData.defaultVectorField)
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(MetricType.IP)
+                            .withIndexType(IndexType.HNSW)
+                            .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                            .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.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
+
 }

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

@@ -60,7 +60,7 @@ public class DescribeIndexTest extends BaseTest {
         milvusClient.describeIndex(
             DescribeIndexParam.newBuilder()
                 .withCollectionName(collection)
-                .withIndexName(CommonData.defaultVectorField)
+                .withIndexName(CommonData.defaultIndex)
                 .build());
     Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 0);
     DescIndexResponseWrapper descIndexResponseWrapper =
@@ -79,11 +79,51 @@ public class DescribeIndexTest extends BaseTest {
 
   @Severity(SeverityLevel.MINOR)
   @Test(
-      description = "Describe Index without field name",
+      description = "Describe Index without collection name",
       expectedExceptions = ParamException.class)
-  public void describeIndexWithoutField() {
+  public void describeIndexWithoutCollection() {
     R<DescribeIndexResponse> describeIndexResponseR =
         milvusClient.describeIndex(
-            DescribeIndexParam.newBuilder().withCollectionName(collection).build());
+            DescribeIndexParam.newBuilder().withIndexName(CommonData.defaultIndex).build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 0);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Describe Index without index name")
+  public void describeIndexWithoutIndexNam() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+        milvusClient.describeIndex(
+            DescribeIndexParam.newBuilder()
+                .withCollectionName(collection)
+                .build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 25);
+    Assert.assertTrue(describeIndexResponseR.getException().getMessage().contains("index not exist"));
+    }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Describe Index when collection does not create index")
+  public void describeIndexWhenCollectionNotCreateIndex() {
+    String newCollection = CommonFunction.createNewCollection();
+    R<DescribeIndexResponse> describeIndexResponseR =
+            milvusClient.describeIndex(
+                    DescribeIndexParam.newBuilder()
+                            .withCollectionName(newCollection)
+                            .build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 25);
+    Assert.assertTrue(describeIndexResponseR.getException().getMessage().contains("index not exist"));
+    milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Describe Index with nonexistent collection")
+  public void describeIndexWithNonexistentCollection() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+            milvusClient.describeIndex(
+                    DescribeIndexParam.newBuilder()
+                            .withCollectionName("NonexistentCollection")
+                            .build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 1);
+    Assert.assertTrue(describeIndexResponseR.getException().getMessage().contains("not found"));
+  }
+
 }

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

@@ -3,6 +3,7 @@ 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.grpc.GetIndexBuildProgressResponse;
 import io.milvus.param.IndexType;
@@ -75,4 +76,24 @@ public class GetIndexBuildProgressTest extends BaseTest {
     Assert.assertEquals(indexBuildProgress.getStatus().intValue(), 0);
     Assert.assertEquals(indexBuildProgress.getData().getIndexedRows(), 0);
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Get Index Build Progress without index name")
+  public void getIndexBuildProgressWithoutIndexName() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+        milvusClient.describeIndex(
+            DescribeIndexParam.newBuilder().withCollectionName(collection).build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 25);
+    Assert.assertTrue(describeIndexResponseR.getException().getMessage().contains("index not exist"));
+    }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Get Index Build Progress without collection",expectedExceptions = ParamException.class)
+  public void getIndexBuildProgressWithoutCollection() {
+    R<DescribeIndexResponse> describeIndexResponseR =
+            milvusClient.describeIndex(
+                    DescribeIndexParam.newBuilder().withIndexName(CommonData.defaultIndex).build());
+    Assert.assertEquals(describeIndexResponseR.getStatus().intValue(), 1);
+  }
+
 }

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

@@ -26,17 +26,18 @@ public class GetIndexStateTest extends BaseTest {
   @BeforeClass(description = "Create collection and index for test")
   public void createCollectionAndIndex() {
     collection = CommonFunction.createNewCollection();
-    R<RpcStatus> indexR = milvusClient.createIndex(
+    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);
+                .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();
   }
 
@@ -64,4 +65,34 @@ public class GetIndexStateTest extends BaseTest {
     Assert.assertEquals(getIndexStateResponseR.getStatus().intValue(), 0);
     Assert.assertEquals(getIndexStateResponseR.getData(), 0);
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Get index state with nonexistent collection")
+  public void getIndexStateWithNonexistentCollection() {
+    R<GetIndexStateResponse> getIndexStateResponseR =
+        milvusClient.getIndexState(
+            GetIndexStateParam.newBuilder()
+                .withCollectionName("NonexistentCollection")
+                .withIndexName(CommonData.defaultVectorField)
+                .build());
+    Assert.assertEquals(getIndexStateResponseR.getStatus().intValue(), 1);
+    Assert.assertTrue(getIndexStateResponseR.getException().getMessage().contains("not found"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Get index state when collection does not create index")
+  public void getIndexStateWhenCollectionNotCreateIndex() {
+    String newCollection = CommonFunction.createNewCollection();
+    R<GetIndexStateResponse> getIndexStateResponseR =
+        milvusClient.getIndexState(
+            GetIndexStateParam.newBuilder()
+                .withCollectionName(newCollection)
+                .withIndexName(CommonData.defaultVectorField)
+                .build());
+    Assert.assertEquals(getIndexStateResponseR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        getIndexStateResponseR.getException().getMessage().contains("index not found"));
+    milvusClient.dropCollection(
+        DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
+  }
 }

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

@@ -4,23 +4,44 @@ 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.grpc.DataType;
 import io.milvus.grpc.MutationResult;
 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.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.ArrayList;
 import java.util.List;
+import java.util.Random;
 import java.util.concurrent.ExecutionException;
 
 @Epic("Index")
 @Feature("InsertAsyncT")
 public class InsertAsyncTest 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());
+  }
   @Test(description = "Insert data Async")
   @Severity(SeverityLevel.BLOCKER)
   public void insertAsyncSuccess() throws ExecutionException, InterruptedException {
@@ -36,4 +57,209 @@ public class InsertAsyncTest extends BaseTest {
     Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 2000);
     System.out.println(mutationResultR.getData());
   }
+  @Severity(SeverityLevel.CRITICAL)
+  @Test(description = "Insert async data into partition ")
+  public void insertAsyncDataIntoPartition() throws ExecutionException, InterruptedException  {
+    List<InsertParam.Field> fields = CommonFunction.generateData(2000);
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withPartitionName(CommonData.defaultPartition)
+                            .withFields(fields)
+                            .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    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 async into String pk and binary vector Collection")
+  public void multipleInsertIntoStringPKAndBinaryCollection() throws ExecutionException, InterruptedException  {
+    List<InsertParam.Field> fields = CommonFunction.generateStringPKBinaryData(2000);
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(stringPKAndBinaryCollection)
+                            .withFields(fields)
+                            .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 2000);
+
+    List<InsertParam.Field> fields2 = CommonFunction.generateStringPKBinaryData(3000);
+    ListenableFuture<R<MutationResult>> rListenableFuture2 =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(stringPKAndBinaryCollection)
+                            .withFields(fields2)
+                            .build());
+    R<MutationResult> mutationResultR2 = rListenableFuture2.get();
+    Assert.assertEquals(mutationResultR2.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR2.getData().getSuccIndexCount(), 3000);
+
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert async into collection not match vector type")
+  public void insertIntoCollectionNotMatchVectorType() throws ExecutionException, InterruptedException  {
+    List<InsertParam.Field> fields = CommonFunction.generateBinaryData(10);
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("The field: VectorFieldAutoTest is not provided"));
+  }
+
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert async into collection not match PK type")
+  public void insertIntoCollectionNotMatchPKType() throws ExecutionException, InterruptedException  {
+    Random ran = new Random();
+    List<String> book_id_array = new ArrayList<>();
+    List<String> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      book_id_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
+      word_count_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_id", DataType.VarChar, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.VarChar, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("book_id data type doesn't match the collection schema"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert async into collection not match scalar type")
+  public void insertIntoCollectionNotMatchScalarType() throws ExecutionException, InterruptedException  {
+    Random ran = new Random();
+    List<Long> book_id_array = new ArrayList<>();
+    List<String> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      book_id_array.add( i);
+      word_count_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_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.VarChar, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("word_count data type doesn't match the collection schema"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert async into collection with auto pk")
+  public void insertIntoCollectionWithAutoPK()  throws ExecutionException, InterruptedException {
+    String newCollectionWithAutoPK = CommonFunction.createNewCollectionWithAutoPK();
+    List<InsertParam.Field> fields = CommonFunction.generateDataWithAutoPK(10);
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(newCollectionWithAutoPK)
+                            .withFields(fields)
+                            .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 10);
+    milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(newCollectionWithAutoPK).build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert async into collection with largest dim")
+  public void insertIntoCollectionWithLargestDim() throws ExecutionException, InterruptedException  {
+    // create largest dim
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+            FieldType.newBuilder()
+                    .withName("book_id")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(true)
+                    .build();
+    FieldType fieldType2 =
+            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+            FieldType.newBuilder()
+                    .withName(CommonData.defaultVectorField)
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(32768)
+                    .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);
+    // general data
+    Random ran = new Random();
+    List<Long> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      word_count_array.add(i + 10000);
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 32768; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+
+    ListenableFuture<R<MutationResult>> rListenableFuture =
+            milvusClient.insertAsync(
+                    InsertParam.newBuilder()
+                            .withCollectionName(collectionName)
+                            .withFields(fields)
+                            .build());
+    R<MutationResult> mutationResultR = rListenableFuture.get();
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 100);
+    milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+  }
+
 }

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

@@ -7,7 +7,10 @@ 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.RpcStatus;
+import io.milvus.param.collection.CreateCollectionParam;
 import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.FieldType;
 import io.milvus.param.dml.InsertParam;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
@@ -21,6 +24,7 @@ import org.testng.annotations.Test;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Random;
 
 @Epic("Index")
 @Feature("Insert")
@@ -93,4 +97,161 @@ public class InsertTest extends BaseTest {
     Assert.assertEquals(mutationResultR2.getData().getSuccIndexCount(), 3000);
 
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert into collection not match vector type")
+  public void insertIntoCollectionNotMatchVectorType() {
+    List<InsertParam.Field> fields = CommonFunction.generateBinaryData(10);
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("The field: VectorFieldAutoTest is not provided"));
+  }
+
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert into collection not match PK type")
+  public void insertIntoCollectionNotMatchPKType() {
+    Random ran = new Random();
+    List<String> book_id_array = new ArrayList<>();
+    List<String> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      book_id_array.add(MathUtil.genRandomStringAndChinese(10) + "-" + i);
+      word_count_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_id", DataType.VarChar, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.VarChar, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("book_id data type doesn't match the collection schema"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert into collection not match scalar type")
+  public void insertIntoCollectionNotMatchScalarType() {
+    Random ran = new Random();
+    List<Long> book_id_array = new ArrayList<>();
+    List<String> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      book_id_array.add( i);
+      word_count_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_id", DataType.Int64, book_id_array));
+    fields.add(new InsertParam.Field("word_count", DataType.VarChar, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("word_count data type doesn't match the collection schema"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert into collection with auto pk")
+  public void insertIntoCollectionWithAutoPK() {
+    String newCollectionWithAutoPK = CommonFunction.createNewCollectionWithAutoPK();
+    List<InsertParam.Field> fields = CommonFunction.generateDataWithAutoPK(10);
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName(newCollectionWithAutoPK)
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 10);
+    milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(newCollectionWithAutoPK).build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert into collection with largest dim")
+  public void insertIntoCollectionWithLargestDim() {
+    // create largest dim
+    String collectionName = "Collection_" + MathUtil.getRandomString(10);
+    FieldType fieldType1 =
+            FieldType.newBuilder()
+                    .withName("book_id")
+                    .withDataType(DataType.Int64)
+                    .withPrimaryKey(true)
+                    .withAutoID(true)
+                    .build();
+    FieldType fieldType2 =
+            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+    FieldType fieldType3 =
+            FieldType.newBuilder()
+                    .withName(CommonData.defaultVectorField)
+                    .withDataType(DataType.FloatVector)
+                    .withDimension(32768)
+                    .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);
+    // general data
+    Random ran = new Random();
+    List<Long> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      word_count_array.add(i + 10000);
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 32768; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
+
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName(collectionName)
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 0);
+    Assert.assertEquals(mutationResultR.getData().getSuccIndexCount(), 100);
+    milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
+  }
+
 }

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

@@ -29,15 +29,16 @@ public class GetMetricsTest extends BaseTest {
   }
 
   @Severity(SeverityLevel.NORMAL)
-  @Test(
-          description =
-                  "Gets the runtime metrics information of Milvus, returns the result in .json format.")
+  @Test(description = "Gets the runtime metrics information with illegal param")
   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"));
+        milvusClient.getMetrics(GetMetricsParam.newBuilder().withRequest(param).build());
+    Assert.assertEquals(getMetricsResponseR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        getMetricsResponseR
+            .getException()
+            .getMessage()
+            .contains("sorry, but this metric type is not implemented"));
   }
 }

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

@@ -47,7 +47,7 @@ public class CreatePartitionTest extends BaseTest {
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "Create partition")
-  public void createPartitionSuccess() {
+  public void createPartition() {
     CreatePartitionParam createPartitionParam =
         CreatePartitionParam.newBuilder()
             .withCollectionName(CommonData.defaultCollection)
@@ -58,9 +58,22 @@ public class CreatePartitionTest extends BaseTest {
     Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
   }
 
+  @Severity(SeverityLevel.BLOCKER)
+  @Test(description = "Create partition repeatedly",dependsOnMethods = "createPartition")
+  public void createPartitionRepeatedly() {
+    CreatePartitionParam createPartitionParam =
+            CreatePartitionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionName(partition)
+                    .build();
+    R<RpcStatus> rpcStatusR = milvusClient.createPartition(createPartitionParam);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertEquals(rpcStatusR.getException().getMessage(),"CreatePartition failed: partition name = "+partition+" already exists");
+  }
+
   @Test(
       description = "query float vector from partition ",
-      dependsOnMethods = "createPartitionSuccess")
+      dependsOnMethods = "createPartition")
   @Severity(SeverityLevel.NORMAL)
   public void queryFromEmptyPartition() {
     milvusClient.loadCollection(
@@ -87,7 +100,7 @@ public class CreatePartitionTest extends BaseTest {
 
   @Test(
       description = "query float vector from partition AfterInsertData",
-      dependsOnMethods = {"createPartitionSuccess","queryFromEmptyPartition",})
+      dependsOnMethods = {"createPartition","queryFromEmptyPartition",})
   @Severity(SeverityLevel.NORMAL)
   public void queryFromPartitionAfterInsertData() throws InterruptedException {
     List<InsertParam.Field> fields = CommonFunction.generateData(100);

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

@@ -3,13 +3,13 @@ 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.GetPartitionStatisticsResponse;
 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.*;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -26,6 +26,7 @@ import java.util.List;
 @Feature("DropPartition")
 public class DropPartitionTest extends BaseTest {
   public String partition;
+
   @DataProvider(name = "partitionName")
   public Object[][] createPartitionTest() {
     partition = "partition_" + MathUtil.getRandomString(10);
@@ -39,7 +40,7 @@ public class DropPartitionTest extends BaseTest {
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "drop partition", dataProvider = "partitionName")
-  public void dropPartitionTest(String partitionName) {
+  public void dropPartition(String partitionName) {
     R<RpcStatus> rpcStatusR =
         milvusClient.dropPartition(
             DropPartitionParam.newBuilder()
@@ -50,43 +51,128 @@ public class DropPartitionTest extends BaseTest {
     Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
   }
 
-  @Test(
-          description = "query float vector from partition ",
-          dependsOnMethods = "dropPartitionTest")
+  @Test(description = "query float vector from partition ", dependsOnMethods = "dropPartition")
   @Severity(SeverityLevel.NORMAL)
   public void queryFromDroppedPartition() {
     milvusClient.loadCollection(
-            LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build());
+        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);
-              }
-            };
+        new ArrayList<String>() {
+          {
+            add(partition);
+          }
+        };
     QueryParam queryParam =
-            QueryParam.newBuilder()
-                    .withCollectionName(CommonData.defaultCollection)
-                    .withPartitionNames(partitions)
-                    .withOutFields(outFields)
-                    .withExpr(SEARCH_PARAM)
-                    .build();
+        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");
+    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());
+        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");
+    Assert.assertEquals(
+        rpcStatusR.getException().getMessage(),
+        "DropPartition failed: partition NonexistentPartition does not exist");
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "create partition after drop partition ", dependsOnMethods = "dropPartition")
+  public void dropPartitionAfterDropped() {
+    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");
+    milvusClient.dropPartition(
+        DropPartitionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionName(partition)
+            .build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "release partition after drop partition ", dependsOnMethods = "dropPartition")
+  public void releasePartitionAfterDropped() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.releasePartitions(
+            ReleasePartitionsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionNames(Arrays.asList(partition))
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        rpcStatusR
+            .getException()
+            .getMessage()
+            .contains("partitionID of partitionName:" + partition + " can not be find"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "load partition after drop partition ", dependsOnMethods = "dropPartition")
+  public void loadPartitionAfterDropped() {
+    R<RpcStatus> rpcStatusR =
+        milvusClient.loadPartitions(
+            LoadPartitionsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionNames(Arrays.asList(partition))
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        rpcStatusR
+            .getException()
+            .getMessage()
+            .contains("partitionID of partitionName:" + partition + " can not be find"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Has partition after drop partition ", dependsOnMethods = "dropPartition")
+  public void hasPartitionAfterDropped() {
+    R<Boolean> booleanR =
+        milvusClient.hasPartition(
+            HasPartitionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(partition)
+                .build());
+    Assert.assertEquals(booleanR.getStatus().intValue(), 0);
+    Assert.assertEquals(booleanR.getData(), Boolean.FALSE);
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+      description = "Get partition Statistics after drop partition ",
+      dependsOnMethods = "dropPartition")
+  public void getPartitionStatisticsAfterDropped() {
+    R<GetPartitionStatisticsResponse> partitionStatistics =
+        milvusClient.getPartitionStatistics(
+            GetPartitionStatisticsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionName(partition)
+                .build());
+    Assert.assertEquals(partitionStatistics.getStatus().intValue(), 1);
+    Assert.assertTrue(
+        partitionStatistics
+            .getException()
+            .getMessage()
+            .contains("partitionID of partitionName:" + partition + " can not be find"));
   }
 }

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

@@ -8,6 +8,7 @@ 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.milvus.param.partition.ReleasePartitionsParam;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -19,19 +20,27 @@ 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;
+  private String partition2;
 
   @BeforeClass(description = "init partition Name")
   public void createPartitionTest() {
     partition = "partition_" + MathUtil.getRandomString(10);
+    partition2 = "partition_" + MathUtil.getRandomString(10);
     milvusClient.createPartition(
         CreatePartitionParam.newBuilder()
             .withCollectionName(CommonData.defaultCollection)
             .withPartitionName(partition)
             .build());
+    milvusClient.createPartition(
+            CreatePartitionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionName(partition2)
+                    .build());
   }
 
   @AfterClass(description = "delete partition after test")
@@ -41,15 +50,21 @@ public class LoadPartitionsTest extends BaseTest {
             .withCollectionName(CommonData.defaultCollection)
             .withPartitionName(partition)
             .build());
+    milvusClient.dropPartition(
+            DropPartitionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withPartitionName(partition2)
+                    .build());
   }
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "load partition")
-  public void loadPartitionSuccess() {
+  public void loadPartition() {
     List<String> partitionNames =
         new ArrayList<String>() {
           {
             add(partition);
+            add(partition2);
           }
         };
     R<RpcStatus> rpcStatusR =
@@ -83,4 +98,30 @@ public class LoadPartitionsTest extends BaseTest {
         rpcStatusR.getException().getMessage(),
         "partitionID of partitionName:" + nonexsitPartition + " can not be find");
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "load partition after release")
+  public void loadPartitionAfterRelease() {
+    // release first
+    milvusClient.releasePartitions(
+        ReleasePartitionsParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .addPartitionName(partition)
+            .build());
+    // load
+    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");
+  }
 }

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

@@ -6,7 +6,6 @@ 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;
@@ -56,7 +55,7 @@ public class ReleasePartitionsTest extends BaseTest {
 
   @Severity(SeverityLevel.BLOCKER)
   @Test(description = "release partition")
-  public void releasePartitionSuccess() {
+  public void releasePartition() {
     R<RpcStatus> rpcStatusR =
         milvusClient.releasePartitions(
             ReleasePartitionsParam.newBuilder()
@@ -69,7 +68,7 @@ public class ReleasePartitionsTest extends BaseTest {
 
   @Test(
           description = "query from partition after release ",
-          dependsOnMethods = "releasePartitionSuccess")
+          dependsOnMethods = "releasePartition")
   @Severity(SeverityLevel.NORMAL)
   public void queryAfterReleasePartition() {
     String SEARCH_PARAM = "book_id in [2,4,6,8]";
@@ -91,4 +90,17 @@ public class ReleasePartitionsTest extends BaseTest {
     Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
     Assert.assertTrue(queryResultsR.getException().getMessage().contains("checkIfLoaded failed when query"));
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "release nonexistent partition")
+  public void releaseNonexistentPartition() {
+    R<RpcStatus> rpcStatusR =
+            milvusClient.releasePartitions(
+                    ReleasePartitionsParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .addPartitionName("NonexistentPartition")
+                            .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(rpcStatusR.getException().getMessage().contains("partitionID of partitionName:NonexistentPartition can not be find"));
+  }
 }

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

@@ -42,4 +42,18 @@ public class GetPersistentSegmentInfoTest extends BaseTest {
     Assert.assertEquals(responseR.getData().getInfos(0).getState(), SegmentState.Flushed);
     System.out.println(responseR.getData());
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(
+          description =
+                  "Gets the information of persistent segments without flush")
+  public void getPersistentSegmentInfoWithoutFlush() {
+    R<GetPersistentSegmentInfoResponse> responseR =
+            milvusClient.getPersistentSegmentInfo(
+                    GetPersistentSegmentInfoParam.newBuilder()
+                            .withCollectionName(CommonData.defaultStringPKCollection)
+                            .build());
+    Assert.assertEquals(responseR.getStatus().intValue(), 0);
+    System.out.println(responseR.getData());
+  }
 }

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

@@ -5,6 +5,7 @@ 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.collection.ReleaseCollectionParam;
 import io.milvus.param.control.GetQuerySegmentInfoParam;
 import io.qameta.allure.*;
 import org.testng.Assert;
@@ -35,4 +36,21 @@ public class GetQuerySegmentInfoTest extends BaseTest {
     Assert.assertEquals(responseR.getStatus().intValue(), 0);
     Assert.assertEquals(responseR.getData().getInfos(0), 0);
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Gets the query information of segments without load")
+  public void getQuerySegmentInfoWithoutLoad() {
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    R<GetQuerySegmentInfoResponse> responseR =
+        milvusClient.getQuerySegmentInfo(
+            GetQuerySegmentInfoParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    System.out.println(responseR.getData());
+    Assert.assertEquals(responseR.getStatus().intValue(), 1);
+    Assert.assertTrue(responseR.getException().getMessage().contains("getSegmentInfo: queryNode"));
+  }
 }