add and modify testcases for sdk v2 (#1292) (#1293)

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

tests/milvustestv2/pom.xml

@@ -18,9 +18,6 @@
         <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 Use-->
-        <aspectj.version>1.9.2</aspectj.version>
-        <allure.version>2.13.2</allure.version>
         <xmlFileName>testng.xml</xmlFileName>
     </properties>
     <dependencies>
@@ -100,6 +97,12 @@
             <artifactId>commons-math3</artifactId>
             <version>3.6.1</version>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/io.milvus/milvus-sdk-java-bulkwriter -->
+        <dependency>
+            <groupId>io.milvus</groupId>
+            <artifactId>milvus-sdk-java-bulkwriter</artifactId>
+            <version>2.5.4</version>
+        </dependency>
     </dependencies>
     <build>
         <finalName>${project.name}</finalName>
@@ -117,32 +120,6 @@
                     </excludes>
                 </configuration>
             </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.22.1</version>
-                <configuration>
-                    <argLine>
-                        -javaagent:"${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar"
-                    </argLine>
-                    <!--generate allure-result-->
-                    <systemProperties>
-                        <!--<org.uncommons.reportng.escape-output>false</org.uncommons.reportng.escape-output>-->
-                        <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>
-            </plugin>
         </plugins>
     </build>
 

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

@@ -5,7 +5,7 @@ package com.zilliz.milvustestv2.common;
  * @Date 2024/1/31 18:03
  */
 public class CommonData {
-    public static long numberEntities=2000;
+    public static long numberEntities=5000;
     public static long batchSize=1000;
     public static int dim=128;
     public static String defaultFloatVectorCollection="FloatVectorCollection";
@@ -49,8 +49,9 @@ public class CommonData {
 
     public static String roleName="role02";
 
-    public static String databaseName="database01";
+    public static String databaseName="database00";
     public static String databaseName2="database02";
+    public static String databaseName1="database01";
 
     public static short defaultValueShort = 1;
     public static int defaultValueInt = 1;
@@ -59,6 +60,12 @@ public class CommonData {
     public static boolean defaultValueBool = true;
     public static String defaultValueString = "1.0";
 
+    public static int groupSize = 3;
+    public static String resourceGroup="resourceGroup01";
+    public static String defaultResourceGroup="__default_resource_group";
+    public static String resourceGroup2="resourceGroup02";
+
+
 
 
 

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

@@ -8,6 +8,13 @@ import com.zilliz.milvustestv2.utils.GenerateUtil;
 
 import com.zilliz.milvustestv2.utils.JsonObjectUtil;
 import com.zilliz.milvustestv2.utils.MathUtil;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import io.milvus.bulkwriter.RemoteBulkWriter;
+import io.milvus.bulkwriter.RemoteBulkWriterParam;
+import io.milvus.bulkwriter.common.clientenum.BulkFileType;
+import io.milvus.bulkwriter.common.clientenum.CloudStorage;
+import io.milvus.bulkwriter.connect.S3ConnectParam;
+import io.milvus.bulkwriter.connect.StorageConnectParam;
 import io.milvus.common.utils.Float16Utils;
 import io.milvus.v2.common.ConsistencyLevel;
 import io.milvus.v2.common.DataType;
@@ -29,16 +36,120 @@ import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 
 import javax.annotation.Nullable;
+import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static com.zilliz.milvustestv2.common.BaseTest.milvusClientV2;
+
 /**
  * @Author yongpeng.li
  * @Date 2024/2/1 15:55
  */
 @Slf4j
 public class CommonFunction {
+    /**
+     * 提供Collection Schema
+     *
+     * @param dim        维度
+     * @param vectorType 向量类型
+     * @return CollectionSchema
+     */
+    public static CreateCollectionReq.CollectionSchema providerCollectionSchema(int dim, DataType vectorType) {
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
+                .autoID(false)
+                .dataType(io.milvus.v2.common.DataType.Int64)
+                .isPrimaryKey(true)
+                .name(CommonData.fieldInt64)
+                .build();
+        CreateCollectionReq.FieldSchema fieldInt32 = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Int32)
+                .name(CommonData.fieldInt32)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldInt16 = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Int16)
+                .name(CommonData.fieldInt16)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldInt8 = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Int8)
+                .name(CommonData.fieldInt8)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldDouble = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Double)
+                .name(CommonData.fieldDouble)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldArray = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Array)
+                .name(CommonData.fieldArray)
+                .elementType(DataType.Int64)
+                .maxCapacity(100)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldBool = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Bool)
+                .name(CommonData.fieldBool)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.VarChar)
+                .name(CommonData.fieldVarchar)
+                .isPrimaryKey(false)
+                .maxLength(100)
+                .build();
+        CreateCollectionReq.FieldSchema fieldFloat = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.Float)
+                .name(CommonData.fieldFloat)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldJson = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.JSON)
+                .name(CommonData.fieldJson)
+                .isPrimaryKey(false)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVector = CreateCollectionReq.FieldSchema.builder()
+                .dataType(vectorType)
+                .isPrimaryKey(false)
+                .build();
+        if (vectorType == DataType.FloatVector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldFloatVector);
+        }
+        if (vectorType == DataType.BinaryVector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldBinaryVector);
+        }
+        if (vectorType == DataType.Float16Vector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldFloat16Vector);
+        }
+        if (vectorType == DataType.BFloat16Vector) {
+            fieldVector.setDimension(dim);
+            fieldVector.setName(CommonData.fieldBF16Vector);
+        }
+        if (vectorType == DataType.SparseFloatVector) {
+            fieldVector.setName(CommonData.fieldSparseVector);
+        }
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
+        fieldSchemaList.add(fieldInt64);
+        fieldSchemaList.add(fieldInt32);
+        fieldSchemaList.add(fieldInt16);
+        fieldSchemaList.add(fieldInt8);
+        fieldSchemaList.add(fieldFloat);
+        fieldSchemaList.add(fieldDouble);
+        fieldSchemaList.add(fieldArray);
+        fieldSchemaList.add(fieldBool);
+        fieldSchemaList.add(fieldJson);
+        fieldSchemaList.add(fieldVarchar);
+        fieldSchemaList.add(fieldVector);
+        return CreateCollectionReq.CollectionSchema.builder()
+                .fieldSchemaList(fieldSchemaList)
+                .build();
+    }
 
     /**
      * 创建DataType vectorType类型向量的collection
@@ -82,7 +193,7 @@ public class CommonFunction {
                 .dataType(DataType.Array)
                 .name(CommonData.fieldArray)
                 .elementType(DataType.Int64)
-                .maxCapacity(1000)
+                .maxCapacity(100)
                 .isPrimaryKey(false)
                 .build();
         CreateCollectionReq.FieldSchema fieldBool = CreateCollectionReq.FieldSchema.builder()
@@ -94,7 +205,7 @@ public class CommonFunction {
                 .dataType(DataType.VarChar)
                 .name(CommonData.fieldVarchar)
                 .isPrimaryKey(false)
-                .maxLength(1000)
+                .maxLength(100)
                 .build();
         CreateCollectionReq.FieldSchema fieldFloat = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Float)
@@ -151,7 +262,7 @@ public class CommonFunction {
                 .description("collection desc")
                 .numShards(1)
                 .build();
-        BaseTest.milvusClientV2.createCollection(createCollectionReq);
+        milvusClientV2.createCollection(createCollectionReq);
         log.info("create collection:" + collectionName);
         return collectionName;
     }
@@ -276,7 +387,7 @@ public class CommonFunction {
                 .description("collection desc")
                 .numShards(1)
                 .build();
-        BaseTest.milvusClientV2.createCollection(createCollectionReq);
+        milvusClientV2.createCollection(createCollectionReq);
         log.info("create collection:" + collectionName);
         return collectionName;
     }
@@ -399,7 +510,7 @@ public class CommonFunction {
                 .description("collection desc")
                 .numShards(1)
                 .build();
-        BaseTest.milvusClientV2.createCollection(createCollectionReq);
+        milvusClientV2.createCollection(createCollectionReq);
         log.info("create collection:" + collectionName);
         return collectionName;
     }
@@ -531,7 +642,7 @@ public class CommonFunction {
                 .description("collection desc")
                 .numShards(1)
                 .build();
-        BaseTest.milvusClientV2.createCollection(createCollectionReq);
+        milvusClientV2.createCollection(createCollectionReq);
         log.info("create collection:" + collectionName);
         return collectionName;
     }
@@ -543,11 +654,11 @@ public class CommonFunction {
      * @param dim 维度
      * @return List<JsonObject>
      */
-    public static List<JsonObject> generateDefaultData(long startId,long num, int dim, DataType vectorType) {
+    public static List<JsonObject> generateDefaultData(long startId, long num, int dim, DataType vectorType) {
         List<JsonObject> jsonList = new ArrayList<>();
         Random ran = new Random();
         Gson gson = new Gson();
-        for (long i = startId; i < (num+startId); i++) {
+        for (long i = startId; i < (num + startId); i++) {
             JsonObject row = new JsonObject();
             row.addProperty(CommonData.fieldInt64, i);
             row.addProperty(CommonData.fieldInt32, (int) i % 32767);
@@ -624,11 +735,11 @@ public class CommonFunction {
      * @param dim 维度
      * @return List<JsonObject>
      */
-    public static List<JsonObject> generateSimpleNullData(long startId,long num, int dim, DataType vectorType) {
+    public static List<JsonObject> generateSimpleNullData(long startId, long num, int dim, DataType vectorType) {
         List<JsonObject> jsonList = new ArrayList<>();
         Random ran = new Random();
         Gson gson = new Gson();
-        for (long i = startId; i < (num+startId); i++) {
+        for (long i = startId; i < (num + startId); i++) {
             JsonObject row = new JsonObject();
             row.addProperty(CommonData.fieldInt64, i);
             row.addProperty(CommonData.fieldInt32, (String) null);
@@ -668,7 +779,7 @@ public class CommonFunction {
             json.addProperty(CommonData.fieldDouble, (double) i);
             json.add(CommonData.fieldArray, gson.toJsonTree(Arrays.asList(i, i + 1, i + 2)));
             json.addProperty(CommonData.fieldBool, i % 2 == 0);
-            if ( i % 2 == 1) {
+            if (i % 2 == 1) {
                 json.addProperty(CommonData.fieldVarchar, "Str" + i);
             }
             json.addProperty(CommonData.fieldFloat, (float) i);
@@ -686,13 +797,13 @@ public class CommonFunction {
      * @param collectionName collection name
      * @return collectionName
      */
-    public static String createSimpleCollection(int dim, String collectionName) {
+    public static String createSimpleCollection(int dim, String collectionName, boolean autoPK) {
         if (collectionName == null) {
             collectionName = "Collection_" + GenerateUtil.getRandomString(10);
         }
-        BaseTest.milvusClientV2.createCollection(CreateCollectionReq.builder()
+        milvusClientV2.createCollection(CreateCollectionReq.builder()
                 .collectionName(collectionName)
-                .autoID(false)
+                .autoID(autoPK)
                 .dimension(dim)
                 .enableDynamicField(false)
                 .build());
@@ -738,7 +849,7 @@ public class CommonFunction {
                 .extraParams(provideExtraParam(indexType))
                 .metricType(metricType)
                 .build();
-        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+        milvusClientV2.createIndex(CreateIndexReq.builder()
                 .collectionName(collectionName)
                 .indexParams(Collections.singletonList(indexParam))
                 .build());
@@ -756,7 +867,7 @@ public class CommonFunction {
             IndexParam indexParam = IndexParam.builder().indexType(IndexParam.IndexType.TRIE).fieldName(x).build();
             indexParams.add(indexParam);
         });
-        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+        milvusClientV2.createIndex(CreateIndexReq.builder()
                 .collectionName(collectionName)
                 .indexParams(indexParams)
                 .build());
@@ -764,7 +875,7 @@ public class CommonFunction {
 
 
     public static void createPartition(String collectionName, String partitionName) {
-        BaseTest.milvusClientV2.createPartition(CreatePartitionReq.builder()
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
                 .collectionName(collectionName)
                 .partitionName(partitionName)
                 .build());
@@ -776,7 +887,7 @@ public class CommonFunction {
         vectors.forEach((v) -> {
             data.add(new FloatVec(v));
         });
-        return BaseTest.milvusClientV2.search(SearchReq.builder()
+        return milvusClientV2.search(SearchReq.builder()
                 .collectionName(collectionName)
                 .outputFields(Lists.newArrayList("*"))
                 .consistencyLevel(ConsistencyLevel.STRONG)
@@ -787,7 +898,8 @@ public class CommonFunction {
     }
 
     /**
-     *  创建一条float32的向量
+     * 创建一条float32的向量
+     *
      * @param dimension 维度
      * @return List<Float>
      */
@@ -935,7 +1047,7 @@ public class CommonFunction {
                 .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.AUTOINDEX))
                 .metricType(provideMetricTypeByVectorType(vectorType))
                 .build();
-        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+        milvusClientV2.createIndex(CreateIndexReq.builder()
                 .collectionName(collection)
                 .indexParams(Collections.singletonList(indexParam))
                 .build());
@@ -999,23 +1111,23 @@ public class CommonFunction {
                 .extraParams(CommonFunction.provideExtraParam(providerIndexType(vectorType)))
                 .metricType(provideMetricTypeByVectorType(vectorType))
                 .build();
-        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+        milvusClientV2.createIndex(CreateIndexReq.builder()
                 .collectionName(collectionName)
                 .indexParams(Collections.singletonList(indexParam))
                 .build());
         if (ifLoad) {
-            BaseTest.milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(collectionName).build());
+            milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(collectionName).build());
         }
-        insertIntoCollectionByBatch(collectionName,numberEntities,CommonData.dim,vectorType);
+        insertIntoCollectionByBatch(collectionName, numberEntities, CommonData.dim, vectorType);
 
     }
 
-    public static void insertIntoCollectionByBatch(String collectionName,long num,int dim,DataType vectorType){
-        long insertRounds = (num / CommonData.batchSize) ==0?1:(num / CommonData.batchSize);
+    public static void insertIntoCollectionByBatch(String collectionName, long num, int dim, DataType vectorType) {
+        long insertRounds = (num / CommonData.batchSize) == 0 ? 1 : (num / CommonData.batchSize);
         for (int i = 0; i < insertRounds; i++) {
-            System.out.println("insert batch:"+(i+1));
-            List<JsonObject> jsonObjects = generateDefaultData(i*CommonData.batchSize, CommonData.batchSize, dim, vectorType);
-            InsertResp insert = BaseTest.milvusClientV2.insert(InsertReq.builder().collectionName(collectionName).data(jsonObjects).build());
+            System.out.println("insert batch:" + (i + 1));
+            List<JsonObject> jsonObjects = generateDefaultData(i * CommonData.batchSize, CommonData.batchSize, dim, vectorType);
+            InsertResp insert = milvusClientV2.insert(InsertReq.builder().collectionName(collectionName).data(jsonObjects).build());
         }
     }
 
@@ -1120,7 +1232,7 @@ public class CommonFunction {
                 .description("collection desc")
                 .numShards(1)
                 .build();
-        BaseTest.milvusClientV2.createCollection(createCollectionReq);
+        milvusClientV2.createCollection(createCollectionReq);
         return collectionName;
     }
 
@@ -1164,7 +1276,7 @@ public class CommonFunction {
      * @return List<JsonObject>
      */
     public static List<JsonObject> genCommonData(String collectionName, long count) {
-        DescribeCollectionResp describeCollectionResp = BaseTest.milvusClientV2.describeCollection(DescribeCollectionReq.builder().collectionName(collectionName).build());
+        DescribeCollectionResp describeCollectionResp = milvusClientV2.describeCollection(DescribeCollectionReq.builder().collectionName(collectionName).build());
         CreateCollectionReq.CollectionSchema collectionSchema = describeCollectionResp.getCollectionSchema();
         List<CreateCollectionReq.FieldSchema> fieldSchemaList = collectionSchema.getFieldSchemaList();
         List<JsonObject> jsonList = new ArrayList<>();
@@ -1302,7 +1414,7 @@ public class CommonFunction {
             indexParamList.add(indexParam);
         }
 
-        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+        milvusClientV2.createIndex(CreateIndexReq.builder()
                 .collectionName(collection)
                 .indexParams(indexParamList)
                 .build());
@@ -1328,20 +1440,21 @@ public class CommonFunction {
             indexParamList.add(indexParam);
         }
 
-        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+        milvusClientV2.createIndex(CreateIndexReq.builder()
                 .collectionName(collection)
                 .indexParams(indexParamList)
                 .build());
     }
 
-    /** Drop Scalar Indexes
+    /**
+     * Drop Scalar Indexes
      *
-     * @param collection collection name
+     * @param collection     collection name
      * @param fieldParamList FieldParamList
      */
     public static void dropScalarCommonIndex(String collection, List<FieldParam> fieldParamList) {
         List<String> fieldNames = fieldParamList.stream().map(FieldParam::getFieldName).collect(Collectors.toList());
-        fieldNames.forEach(x -> BaseTest.milvusClientV2.dropIndex(DropIndexReq.builder()
+        fieldNames.forEach(x -> milvusClientV2.dropIndex(DropIndexReq.builder()
                 .collectionName(collection)
                 .fieldName(x)
                 .indexName(x)
@@ -1415,6 +1528,71 @@ public class CommonFunction {
         }
         return extraParam;
     }
+
+    /**
+     * 提供bulk import时候的files
+     *
+     * @param collection   collection
+     * @param bulkFileType 文件类型--枚举类bulkFileType
+     * @return
+     */
+    public static List<List<String>> providerBatchFiles(String collection, BulkFileType bulkFileType, long count) {
+        // 查询schema
+        DescribeCollectionResp describeCollectionResp = milvusClientV2.describeCollection(DescribeCollectionReq.builder().collectionName(collection).build());
+        CreateCollectionReq.CollectionSchema collectionSchema = describeCollectionResp.getCollectionSchema();
+        RemoteBulkWriter remoteBulkWriter = buildRemoteBulkWriter(collectionSchema, bulkFileType);
+        List<JsonObject> jsonObjects = CommonFunction.genCommonData(collection, count);
+        jsonObjects.forEach(x->{
+            try {
+                remoteBulkWriter.appendRow(x);
+            } catch (IOException | InterruptedException e) {
+                log.error(e.getMessage());
+            }
+        });
+        System.out.printf("%s rows appends%n", remoteBulkWriter.getTotalRowCount());
+        System.out.printf("%s rows in buffer not flushed%n", remoteBulkWriter.getBufferRowCount());
+        try {
+            remoteBulkWriter.commit(false);
+        } catch (InterruptedException e) {
+            log.error(e.getMessage());
+        }
+        List<List<String>> batchFiles = remoteBulkWriter.getBatchFiles();
+        System.out.printf("Remote writer done! output remote files: %s%n", batchFiles);
+        return batchFiles;
+    }
+
+    /**
+     * 为开源提供bulk writer
+     *
+     * @param collectionSchema
+     * @param bulkFileType
+     * @return
+     */
+    private static RemoteBulkWriter buildRemoteBulkWriter(CreateCollectionReq.CollectionSchema collectionSchema, BulkFileType bulkFileType) {
+        StorageConnectParam connectParam = S3ConnectParam.newBuilder()
+                .withEndpoint(System.getProperty("minio") == null ? PropertyFilesUtil.getRunValue("minio") : System.getProperty("minio"))
+                .withCloudName(CloudStorage.MINIO.getCloudName())
+                .withBucketName("milvus-bucket")
+                .withAccessKey("minioadmin")
+                .withSecretKey("minioadmin")
+                .withRegion("")
+                .build();
+        RemoteBulkWriterParam bulkWriterParam = RemoteBulkWriterParam.newBuilder()
+                .withCollectionSchema(collectionSchema)
+                .withRemotePath("bulk_data")
+                .withFileType(bulkFileType)
+                .withChunkSize(512 * 1024 * 1024)
+                .withConnectParam(connectParam)
+                .build();
+        RemoteBulkWriter remoteBulkWriter = null;
+        try {
+            remoteBulkWriter = new RemoteBulkWriter(bulkWriterParam);
+        } catch (IOException e) {
+            log.error(e.getMessage());
+        }
+        return remoteBulkWriter;
+    }
+
 }
 
 

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/utils/FileUtils.java

@@ -1,6 +1,11 @@
 package com.zilliz.milvustestv2.utils;
 
 
+import io.minio.BucketExistsArgs;
+import io.minio.MakeBucketArgs;
+import io.minio.MinioClient;
+import io.minio.UploadObjectArgs;
+import io.minio.errors.MinioException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -59,4 +64,48 @@ public class FileUtils {
     }
   }
 
+  public static void multiFilesUpload(String path, List<String> fileNameList, String bucketFolder)
+          throws IOException, NoSuchAlgorithmException, InvalidKeyException {
+    if (bucketFolder == null) bucketFolder = "";
+    try {
+      // Create a minioClient with the MinIO server playground, its access key and secret key.
+      MinioClient minioClient =
+              MinioClient.builder()
+                      .endpoint(PropertyFilesUtil.getRunValue("minio"))
+                      .credentials(
+                              PropertyFilesUtil.getRunValue("accesskey"),
+                              PropertyFilesUtil.getRunValue("secretkey"))
+                      .build();
+
+      // Make 'jsonBucket' bucket if not exist.
+      boolean found =
+              minioClient.bucketExists(BucketExistsArgs.builder().bucket("milvus-bucket").build());
+      if (!found) {
+        // Make a new bucket called 'jsonBucket'.
+        minioClient.makeBucket(MakeBucketArgs.builder().bucket("milvus-bucket").build());
+      } else {
+        System.out.println("Bucket 'milvus-bucket' already exists.");
+      }
+
+      for (String fileName : fileNameList) {
+        minioClient.uploadObject(
+                UploadObjectArgs.builder()
+                        .bucket("milvus-bucket")
+                        .object(bucketFolder + "/" + fileName)
+                        .filename(path + fileName)
+                        .build());
+        System.out.println(
+                "'"
+                        + path
+                        + fileName
+                        + "' is successfully uploaded as "
+                        + "object '"
+                        + fileName
+                        + "' to bucket 'milvus-bucket'.");
+      }
+    } catch (MinioException e) {
+      System.out.println("Error occurred: " + e);
+      System.out.println("HTTP trace: " + e.httpTrace());
+    }
+  }
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/Issue.java

@@ -0,0 +1,122 @@
+package com.zilliz.milvustestv2;
+
+import com.google.common.collect.Interner;
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import io.milvus.v2.client.ConnectConfig;
+import io.milvus.v2.client.MilvusClientV2;
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.CreateCollectionReq;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import io.milvus.v2.service.index.request.CreateIndexReq;
+import io.milvus.v2.service.vector.request.QueryReq;
+import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.request.data.BaseVector;
+import io.milvus.v2.service.vector.response.QueryResp;
+import io.milvus.v2.service.vector.response.SearchResp;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Issue {
+    public static void main2(String[] args) {
+        MilvusClientV2 milvusClientV2New=new MilvusClientV2(ConnectConfig.builder()
+                .uri("https://in01-f08382f0719b15b.aws-us-west-2.vectordb-uat3.zillizcloud.com:19532")
+                .token("6aff239bed5702130e09ad03a3379a71034a3e7b4160de384dce58c501e5bf98e49816c670b4b6335f51276c294976ce6ba25fa4")
+                .connectTimeoutMs(5000L)
+                .build());
+        String newCollectionName="indexpool";
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
+                .autoID(false)
+                .dataType(io.milvus.v2.common.DataType.Int64)
+                .isPrimaryKey(true)
+                .name(CommonData.fieldInt64)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.VarChar)
+                .name(CommonData.fieldVarchar)
+                .isPrimaryKey(false)
+                .maxLength(65535)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVector = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.FloatVector)
+                .isPrimaryKey(false)
+                .name(CommonData.fieldFloatVector)
+                .dimension(128)
+                .build();
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
+        fieldSchemaList.add(fieldInt64);
+        fieldSchemaList.add(fieldVarchar);
+        fieldSchemaList.add(fieldVector);
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
+                .fieldSchemaList(fieldSchemaList)
+                .build();
+        CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
+                .collectionSchema(collectionSchema)
+                .collectionName(newCollectionName)
+                .enableDynamicField(false)
+                .description("collection desc")
+                .numShards(1)
+                .build();
+        milvusClientV2New.createCollection(createCollectionReq);
+
+        IndexParam varcharIndexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldVarchar)
+                .indexType(IndexParam.IndexType.AUTOINDEX)
+                .build();
+        IndexParam vectorIndexParam = IndexParam.builder()
+                .fieldName(CommonData.fieldFloatVector)
+                .indexType(IndexParam.IndexType.AUTOINDEX)
+                .build();
+        milvusClientV2New.createIndex(CreateIndexReq.builder()
+                .collectionName(newCollectionName)
+                .indexParams(Lists.newArrayList(varcharIndexParam,vectorIndexParam))
+                .build());
+//        CommonFunction.genCommonData()
+
+    }
+
+    public static void main(String[] args) {
+        MilvusClientV2 milvusClientV2New=new MilvusClientV2(ConnectConfig.builder()
+                .uri("https://in01-8d2d543507bfe37.aws-us-west-2.vectordb-uat3.zillizcloud.com:19542")
+                .token("6aff239bed5702130e09ad03a3379a71034a3e7b4160de384dce58c501e5bf98e49816c670b4b6335f51276c294976ce6ba25fa4")
+                .connectTimeoutMs(5000L)
+                .build());
+        String newCollectionName="Collection_ypMcrBTRZC";
+
+        QueryResp query = milvusClientV2New.query(QueryReq.builder()
+                .collectionName(newCollectionName)
+                .filter("VarChar_0 like \"9%\"")
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+                        .limit(1000L)
+                .build());
+        List<QueryResp.QueryResult> queryResults = query.getQueryResults();
+List<String> pkList=new ArrayList<>();
+        for (QueryResp.QueryResult queryResult : queryResults) {
+            pkList.add(queryResult.getEntity().get("VarChar_0").toString());
+        }
+        System.out.println(pkList.size());
+
+        List<BaseVector> data = CommonFunction.providerBaseVector(1, 768, DataType.FloatVector);
+        List<Integer> result=new ArrayList<>();
+        for (String s : pkList) {
+        SearchResp search = milvusClientV2New.search(SearchReq.builder()
+                .collectionName(newCollectionName)
+                .outputFields(Lists.newArrayList("VarChar_0"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .filter("VarChar_0 in [\""+s+"\"]")
+                .data(data)
+                .topK(1)
+                .build());
+            System.out.println("Search："+s+"    "+search.getSearchResults().get(0));
+            result.add(search.getSearchResults().get(0).size());
+        }
+        System.out.println(result);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/bulk/BulkImportTest.java

@@ -0,0 +1,57 @@
+package com.zilliz.milvustestv2.bulk;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import io.milvus.bulkwriter.BulkImport;
+import io.milvus.bulkwriter.common.clientenum.BulkFileType;
+import io.milvus.bulkwriter.request.import_.MilvusImportRequest;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+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;
+
+public class BulkImportTest extends BaseTest {
+
+    String collectionName;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        collectionName = CommonFunction.createSimpleCollection(CommonData.dim, null,false);
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropCollection(DropCollectionReq.builder()
+                .collectionName(collectionName).build());
+    }
+
+    @Test(description = "bulk import", groups = {"L1"})
+    public void bulkImport() {
+        List<List<String>> batchFiles = CommonFunction.providerBatchFiles(collectionName, BulkFileType.PARQUET,10000);
+
+        MilvusImportRequest milvusImportRequest = MilvusImportRequest.builder()
+                .collectionName(collectionName)
+                .files(batchFiles)
+                .build();
+        String bulkImportResult = BulkImport.bulkImport(
+                System.getProperty("uri")== null? PropertyFilesUtil.getRunValue("uri"):System.getProperty("uri"),
+                milvusImportRequest);
+        JsonObject bulkImportJO= JsonParser.parseString(bulkImportResult).getAsJsonObject();
+        String jobId = bulkImportJO.getAsJsonObject("data").get("jobId").getAsString();
+        System.out.println(jobId);
+        Assert.assertNotNull(jobId);
+
+    }
+
+
+
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/bulk/GetImportProgressTest.java

@@ -0,0 +1,57 @@
+package com.zilliz.milvustestv2.bulk;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import io.milvus.bulkwriter.BulkImport;
+import io.milvus.bulkwriter.common.clientenum.BulkFileType;
+import io.milvus.bulkwriter.request.describe.MilvusDescribeImportRequest;
+import io.milvus.bulkwriter.request.import_.MilvusImportRequest;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class GetImportProgressTest extends BaseTest {
+    String collectionName;
+    String jobId;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        collectionName = CommonFunction.createSimpleCollection(CommonData.dim, null, false);
+        List<List<String>> batchFiles = CommonFunction.providerBatchFiles(collectionName, BulkFileType.PARQUET, 10000);
+
+        MilvusImportRequest milvusImportRequest = MilvusImportRequest.builder()
+                .collectionName(collectionName)
+                .files(batchFiles)
+                .build();
+        String bulkImportResult = BulkImport.bulkImport(
+                System.getProperty("uri") == null ? PropertyFilesUtil.getRunValue("uri") : System.getProperty("uri"),
+                milvusImportRequest);
+        JsonObject bulkImportJO = JsonParser.parseString(bulkImportResult).getAsJsonObject();
+        jobId = bulkImportJO.getAsJsonObject("data").get("jobId").getAsString();
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropCollection(DropCollectionReq.builder()
+                .collectionName(collectionName).build());
+    }
+
+    @Test(description = "get import progress", groups = {"Smoke"})
+    public void getImportProgress() {
+        MilvusDescribeImportRequest request = MilvusDescribeImportRequest.builder()
+                .jobId(jobId)
+                .build();
+        String importProgress = BulkImport.getImportProgress(System.getProperty("uri") == null ? PropertyFilesUtil.getRunValue("uri") : System.getProperty("uri"),
+                request);
+        JsonObject jsonObject = JsonParser.parseString(importProgress).getAsJsonObject();
+        Assert.assertEquals(jsonObject.get("code").getAsInt(), 0);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/bulk/ListImportJobsTest.java

@@ -0,0 +1,58 @@
+package com.zilliz.milvustestv2.bulk;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import io.milvus.bulkwriter.BulkImport;
+import io.milvus.bulkwriter.common.clientenum.BulkFileType;
+import io.milvus.bulkwriter.request.import_.MilvusImportRequest;
+import io.milvus.bulkwriter.request.list.MilvusListImportJobsRequest;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class ListImportJobsTest extends BaseTest {
+    String collectionName;
+    String jobId;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        collectionName = CommonFunction.createSimpleCollection(CommonData.dim, null, false);
+        List<List<String>> batchFiles = CommonFunction.providerBatchFiles(collectionName, BulkFileType.PARQUET, 10000);
+
+        MilvusImportRequest milvusImportRequest = MilvusImportRequest.builder()
+                .collectionName(collectionName)
+                .files(batchFiles)
+                .build();
+        String bulkImportResult = BulkImport.bulkImport(
+                System.getProperty("uri") == null ? PropertyFilesUtil.getRunValue("uri") : System.getProperty("uri"),
+                milvusImportRequest);
+        JsonObject bulkImportJO = JsonParser.parseString(bulkImportResult).getAsJsonObject();
+        jobId = bulkImportJO.getAsJsonObject("data").get("jobId").getAsString();
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropCollection(DropCollectionReq.builder()
+                .collectionName(collectionName).build());
+    }
+
+
+    @Test(description = "list import jobs", groups = {"Smoke"})
+    public void listImportJobs() {
+        String s = BulkImport.listImportJobs(System.getProperty("uri") == null ? PropertyFilesUtil.getRunValue("uri") : System.getProperty("uri"),
+                MilvusListImportJobsRequest.builder().collectionName(collectionName).build());
+        System.out.println(s);
+        JsonObject asJsonObject = JsonParser.parseString(s).getAsJsonObject();
+        Assert.assertEquals(asJsonObject.get("code").getAsInt(), 0);
+        String jobIdStr = asJsonObject.get("data").getAsJsonObject().get("records").getAsJsonArray().get(0).getAsJsonObject().get("jobId").getAsString();
+        Assert.assertEquals(jobIdStr, jobId);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/collection/AlterCollectionFieldTest.java

@@ -0,0 +1,47 @@
+package com.zilliz.milvustestv2.collection;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.AlterCollectionFieldReq;
+import io.milvus.v2.service.collection.request.CreateCollectionReq;
+import io.milvus.v2.service.collection.request.DescribeCollectionReq;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
+import org.checkerframework.checker.units.qual.A;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+public class AlterCollectionFieldTest extends BaseTest {
+
+    String newCollection;
+
+    @BeforeClass(alwaysRun = true)
+    public void intiTestData() {
+        newCollection = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+    }
+
+
+    @Test(description = "alter collection field", groups = {"Smoke"})
+    public void alterCollectionField() {
+        milvusClientV2.alterCollectionField(AlterCollectionFieldReq.builder()
+                .collectionName(newCollection)
+                .fieldName(CommonData.fieldVarchar)
+                .property("max_length", "99")
+                .build());
+        DescribeCollectionResp describeCollectionResp = milvusClientV2.describeCollection(DescribeCollectionReq.builder()
+                .collectionName(newCollection)
+                .build());
+        CreateCollectionReq.CollectionSchema collectionSchema = describeCollectionResp.getCollectionSchema();
+        CreateCollectionReq.FieldSchema field = collectionSchema.getField(CommonData.fieldVarchar);
+        Assert.assertEquals(field.getMaxLength(), 99);
+    }
+}

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

@@ -1,12 +1,16 @@
 package com.zilliz.milvustestv2.collection;
 
+import com.google.common.collect.Lists;
 import com.zilliz.milvustestv2.common.BaseTest;
 import com.zilliz.milvustestv2.common.CommonData;
 import com.zilliz.milvustestv2.common.CommonFunction;
-import io.milvus.common.resourcegroup.ResourceGroupConfig;
+import com.zilliz.milvustestv2.utils.MathUtil;
+import io.milvus.common.clientenum.FunctionType;
+import io.milvus.param.Constant;
 import io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.*;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
 import io.milvus.v2.service.collection.response.ListCollectionsResp;
 import io.milvus.v2.service.vector.response.SearchResp;
 import org.testng.Assert;
@@ -14,10 +18,7 @@ import org.testng.annotations.AfterClass;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-import javax.ws.rs.ext.Provider;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 
 /**
  * @Author yongpeng.li
@@ -25,19 +26,26 @@ import java.util.List;
  */
 
 public class CreateCollectionTest extends BaseTest {
-    String simpleCollection="simpleCollection";
-    String repeatCollection="repeatCollection";
-    String collectionNameWithIndex="collectionNameWithIndex";
+    String simpleCollection = "simpleCollection";
+    String repeatCollection = "repeatCollection";
+    String collectionNameWithIndex = "collectionNameWithIndex";
+    String collectionNameWithNull = "collectionNameWithNull";
+    String collectionNameWithDefault = "collectionNameWithDefault";
+    String collectionNameWithNullAndDefault = "collectionNameWithNullAndDefault";
+
     @AfterClass(alwaysRun = true)
-    public void cleanTestData(){
+    public void cleanTestData() {
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(simpleCollection).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(repeatCollection).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionNameWithIndex).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionNameWithNull).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionNameWithDefault).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collectionNameWithNullAndDefault).build());
 
     }
 
     @DataProvider(name = "VectorTypeList")
-    public Object[][] providerVectorType(){
+    public Object[][] providerVectorType() {
         return new Object[][]{
                 {DataType.FloatVector},
                 {DataType.BinaryVector},
@@ -46,18 +54,20 @@ public class CreateCollectionTest extends BaseTest {
                 {DataType.SparseFloatVector},
         };
     }
+
     @Test(description = "Create simple collection success", groups = {"Smoke"})
-    public void createSimpleCollectionSuccess(){
+    public void createSimpleCollectionSuccess() {
         milvusClientV2.createCollection(CreateCollectionReq.builder()
-                        .collectionName(simpleCollection)
-                        .dimension(CommonData.dim)
-                        .autoID(false)
+                .collectionName(simpleCollection)
+                .dimension(CommonData.dim)
+                .autoID(false)
                 .build());
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
         Assert.assertTrue(listCollectionsResp.getCollectionNames().contains("simpleCollection"));
     }
+
     @Test(description = "Create duplicate collection", groups = {"Smoke"})
-    public void createDuplicateSimpleCollection(){
+    public void createDuplicateSimpleCollection() {
         milvusClientV2.createCollection(CreateCollectionReq.builder()
                 .collectionName(repeatCollection)
                 .dimension(CommonData.dim)
@@ -66,7 +76,7 @@ public class CreateCollectionTest extends BaseTest {
         try {
             milvusClientV2.createCollection(CreateCollectionReq.builder()
                     .collectionName(repeatCollection)
-                    .dimension(CommonData.dim+1)
+                    .dimension(CommonData.dim + 1)
                     .autoID(true)
                     .build());
         } catch (Exception e) {
@@ -75,69 +85,69 @@ public class CreateCollectionTest extends BaseTest {
     }
 
     @Test(description = "Create collection with index params,will auto load", groups = {"Smoke"})
-    public void createCollectionWithIndexParams(){
-        CreateCollectionReq.FieldSchema fieldInt64=CreateCollectionReq.FieldSchema.builder()
+    public void createCollectionWithIndexParams() {
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
                 .autoID(false)
                 .dataType(io.milvus.v2.common.DataType.Int64)
                 .isPrimaryKey(true)
                 .name(CommonData.fieldInt64)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt32=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt32 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int32)
                 .name(CommonData.fieldInt32)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt16=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt16 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int16)
                 .name(CommonData.fieldInt16)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt8=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt8 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int8)
                 .name(CommonData.fieldInt8)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldDouble=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldDouble = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Double)
                 .name(CommonData.fieldDouble)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldArray=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldArray = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Array)
                 .name(CommonData.fieldArray)
                 .elementType(DataType.Int64)
                 .maxCapacity(1000)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldBool=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldBool = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Bool)
                 .name(CommonData.fieldBool)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldVarchar=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.VarChar)
                 .name(CommonData.fieldVarchar)
                 .isPrimaryKey(false)
                 .maxLength(1000)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloat=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloat = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Float)
                 .name(CommonData.fieldFloat)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldJson=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldJson = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.JSON)
                 .name(CommonData.fieldJson)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloatVector=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloatVector = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.FloatVector)
                 .name(CommonData.fieldFloatVector)
                 .isPrimaryKey(false)
                 .dimension(CommonData.dim)
                 .build();
 
-        List<CreateCollectionReq.FieldSchema> fieldSchemaList=new ArrayList<>();
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
         fieldSchemaList.add(fieldInt64);
         fieldSchemaList.add(fieldInt32);
         fieldSchemaList.add(fieldInt16);
@@ -149,7 +159,7 @@ public class CreateCollectionTest extends BaseTest {
         fieldSchemaList.add(fieldJson);
         fieldSchemaList.add(fieldVarchar);
         fieldSchemaList.add(fieldFloatVector);
-        CreateCollectionReq.CollectionSchema collectionSchema= CreateCollectionReq.CollectionSchema.builder()
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
                 .fieldSchemaList(fieldSchemaList)
                 .build();
         IndexParam indexParam = IndexParam.builder()
@@ -170,14 +180,14 @@ public class CreateCollectionTest extends BaseTest {
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
         Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithIndex));
         //insert
-        CommonFunction.generateDefaultData(0,100,CommonData.dim,DataType.FloatVector);
+        CommonFunction.generateDefaultData(0, 100, CommonData.dim, DataType.FloatVector);
         // search
         SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithIndex);
-        Assert.assertEquals(searchResp.getSearchResults().size(),10);
+        Assert.assertEquals(searchResp.getSearchResults().size(), 10);
     }
 
-    @Test(description="create collection with different vector ", groups={"Smoke"}, dataProvider="VectorTypeList")
-    public void createCollectionWithDifferentVector(DataType vectorType){
+    @Test(description = "create collection with different vector ", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void createCollectionWithDifferentVector(DataType vectorType) {
         String newCollection = CommonFunction.createNewCollection(CommonData.dim, null, vectorType);
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
         Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(newCollection));
@@ -185,38 +195,38 @@ public class CreateCollectionTest extends BaseTest {
     }
 
     @Test(description = "Create collection with Null Data, will auto load", groups = {"Smoke"})
-    public void createCollectionWithNullData(){
-        CreateCollectionReq.FieldSchema fieldInt64=CreateCollectionReq.FieldSchema.builder()
+    public void createCollectionWithNullData() {
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
                 .autoID(false)
                 .dataType(io.milvus.v2.common.DataType.Int64)
                 .isPrimaryKey(true)
                 .name(CommonData.fieldInt64)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt32=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt32 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int32)
                 .name(CommonData.fieldInt32)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt16=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt16 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int16)
                 .name(CommonData.fieldInt16)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt8=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt8 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int8)
                 .name(CommonData.fieldInt8)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldDouble=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldDouble = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Double)
                 .name(CommonData.fieldDouble)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldArray=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldArray = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Array)
                 .name(CommonData.fieldArray)
                 .elementType(DataType.Int64)
@@ -224,39 +234,39 @@ public class CreateCollectionTest extends BaseTest {
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldBool=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldBool = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Bool)
                 .name(CommonData.fieldBool)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldVarchar=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.VarChar)
                 .name(CommonData.fieldVarchar)
                 .isPrimaryKey(false)
                 .maxLength(1000)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloat=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloat = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Float)
                 .name(CommonData.fieldFloat)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldJson=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldJson = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.JSON)
                 .name(CommonData.fieldJson)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloatVector=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloatVector = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.FloatVector)
                 .name(CommonData.fieldFloatVector)
                 .isPrimaryKey(false)
                 .dimension(CommonData.dim)
                 .build();
 
-        List<CreateCollectionReq.FieldSchema> fieldSchemaList=new ArrayList<>();
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
         fieldSchemaList.add(fieldInt64);
         fieldSchemaList.add(fieldInt32);
         fieldSchemaList.add(fieldInt16);
@@ -268,7 +278,7 @@ public class CreateCollectionTest extends BaseTest {
         fieldSchemaList.add(fieldJson);
         fieldSchemaList.add(fieldVarchar);
         fieldSchemaList.add(fieldFloatVector);
-        CreateCollectionReq.CollectionSchema collectionSchema= CreateCollectionReq.CollectionSchema.builder()
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
                 .fieldSchemaList(fieldSchemaList)
                 .build();
         IndexParam indexParam = IndexParam.builder()
@@ -279,7 +289,7 @@ public class CreateCollectionTest extends BaseTest {
                 .build();
         CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
                 .collectionSchema(collectionSchema)
-                .collectionName(collectionNameWithIndex)
+                .collectionName(collectionNameWithNull)
                 .enableDynamicField(false)
                 .indexParams(Collections.singletonList(indexParam))
                 .numShards(1)
@@ -287,85 +297,85 @@ public class CreateCollectionTest extends BaseTest {
         BaseTest.milvusClientV2.createCollection(createCollectionReq);
 
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
-        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithIndex));
+        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithNull));
         //insert
-        CommonFunction.generateDefaultData(0,100,CommonData.dim,DataType.FloatVector);
+        CommonFunction.generateDefaultData(0, 100, CommonData.dim, DataType.FloatVector);
         // search
-        SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithIndex);
-        Assert.assertEquals(searchResp.getSearchResults().size(),10);
+        SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithNull);
+        Assert.assertEquals(searchResp.getSearchResults().size(), 10);
     }
 
     @Test(description = "Create collection with Default Data, will auto load", groups = {"Smoke"})
-    public void createCollectionWithDefaultData(){
-        CreateCollectionReq.FieldSchema fieldInt64=CreateCollectionReq.FieldSchema.builder()
+    public void createCollectionWithDefaultData() {
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
                 .autoID(false)
                 .dataType(io.milvus.v2.common.DataType.Int64)
                 .isPrimaryKey(true)
                 .name(CommonData.fieldInt64)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt32=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt32 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int32)
                 .name(CommonData.fieldInt32)
                 .isPrimaryKey(false)
                 .defaultValue(CommonData.defaultValueInt)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt16=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt16 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int16)
                 .name(CommonData.fieldInt16)
                 .isPrimaryKey(false)
                 .defaultValue(CommonData.defaultValueShort)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt8=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt8 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int8)
                 .name(CommonData.fieldInt8)
                 .isPrimaryKey(false)
                 .defaultValue(CommonData.defaultValueShort)
                 .build();
-        CreateCollectionReq.FieldSchema fieldDouble=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldDouble = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Double)
                 .name(CommonData.fieldDouble)
                 .isPrimaryKey(false)
                 .defaultValue(CommonData.defaultValueDouble)
                 .build();
-        CreateCollectionReq.FieldSchema fieldArray=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldArray = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Array)
                 .name(CommonData.fieldArray)
                 .elementType(DataType.Int64)
                 .maxCapacity(1000)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldBool=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldBool = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Bool)
                 .name(CommonData.fieldBool)
                 .isPrimaryKey(false)
                 .defaultValue(CommonData.defaultValueBool)
                 .build();
-        CreateCollectionReq.FieldSchema fieldVarchar=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.VarChar)
                 .name(CommonData.fieldVarchar)
                 .isPrimaryKey(false)
                 .maxLength(1000)
                 .defaultValue(CommonData.defaultValueString)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloat=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloat = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Float)
                 .name(CommonData.fieldFloat)
                 .isPrimaryKey(false)
                 .defaultValue(CommonData.defaultValueFloat)
                 .build();
-        CreateCollectionReq.FieldSchema fieldJson=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldJson = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.JSON)
                 .name(CommonData.fieldJson)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloatVector=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloatVector = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.FloatVector)
                 .name(CommonData.fieldFloatVector)
                 .isPrimaryKey(false)
                 .dimension(CommonData.dim)
                 .build();
 
-        List<CreateCollectionReq.FieldSchema> fieldSchemaList=new ArrayList<>();
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
         fieldSchemaList.add(fieldInt64);
         fieldSchemaList.add(fieldInt32);
         fieldSchemaList.add(fieldInt16);
@@ -377,7 +387,7 @@ public class CreateCollectionTest extends BaseTest {
         fieldSchemaList.add(fieldJson);
         fieldSchemaList.add(fieldVarchar);
         fieldSchemaList.add(fieldFloatVector);
-        CreateCollectionReq.CollectionSchema collectionSchema= CreateCollectionReq.CollectionSchema.builder()
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
                 .fieldSchemaList(fieldSchemaList)
                 .build();
         IndexParam indexParam = IndexParam.builder()
@@ -388,7 +398,7 @@ public class CreateCollectionTest extends BaseTest {
                 .build();
         CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
                 .collectionSchema(collectionSchema)
-                .collectionName(collectionNameWithIndex)
+                .collectionName(collectionNameWithDefault)
                 .enableDynamicField(false)
                 .indexParams(Collections.singletonList(indexParam))
                 .numShards(1)
@@ -396,65 +406,65 @@ public class CreateCollectionTest extends BaseTest {
         BaseTest.milvusClientV2.createCollection(createCollectionReq);
 
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
-        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithIndex));
+        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithDefault));
         //insert
-        CommonFunction.generateDefaultData(0,100,CommonData.dim,DataType.FloatVector);
+        CommonFunction.generateDefaultData(0, 100, CommonData.dim, DataType.FloatVector);
         // search
-        SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithIndex);
-        Assert.assertEquals(searchResp.getSearchResults().size(),10);
+        SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithDefault);
+        Assert.assertEquals(searchResp.getSearchResults().size(), 10);
     }
 
     @Test(description = "Create collection with nullable and Default Data, will auto load", groups = {"Smoke"})
-    public void createCollectionWithNullAndDefaultData(){
-        CreateCollectionReq.FieldSchema fieldInt64=CreateCollectionReq.FieldSchema.builder()
+    public void createCollectionWithNullAndDefaultData() {
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
                 .autoID(false)
                 .dataType(io.milvus.v2.common.DataType.Int64)
                 .isPrimaryKey(true)
                 .name(CommonData.fieldInt64)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt32=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt32 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int32)
                 .name(CommonData.fieldInt32)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .defaultValue(CommonData.defaultValueInt)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt16=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt16 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int16)
                 .name(CommonData.fieldInt16)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .defaultValue(CommonData.defaultValueShort)
                 .build();
-        CreateCollectionReq.FieldSchema fieldInt8=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldInt8 = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Int8)
                 .name(CommonData.fieldInt8)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .defaultValue(CommonData.defaultValueShort)
                 .build();
-        CreateCollectionReq.FieldSchema fieldDouble=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldDouble = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Double)
                 .name(CommonData.fieldDouble)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .defaultValue(CommonData.defaultValueDouble)
                 .build();
-        CreateCollectionReq.FieldSchema fieldArray=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldArray = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Array)
                 .name(CommonData.fieldArray)
                 .elementType(DataType.Int64)
                 .maxCapacity(1000)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldBool=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldBool = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Bool)
                 .name(CommonData.fieldBool)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .defaultValue(CommonData.defaultValueBool)
                 .build();
-        CreateCollectionReq.FieldSchema fieldVarchar=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.VarChar)
                 .name(CommonData.fieldVarchar)
                 .isPrimaryKey(false)
@@ -462,26 +472,26 @@ public class CreateCollectionTest extends BaseTest {
                 .isNullable(true)
                 .defaultValue(CommonData.defaultValueString)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloat=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloat = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.Float)
                 .name(CommonData.fieldFloat)
                 .isPrimaryKey(false)
                 .isNullable(true)
                 .defaultValue(CommonData.defaultValueFloat)
                 .build();
-        CreateCollectionReq.FieldSchema fieldJson=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldJson = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.JSON)
                 .name(CommonData.fieldJson)
                 .isPrimaryKey(false)
                 .build();
-        CreateCollectionReq.FieldSchema fieldFloatVector=CreateCollectionReq.FieldSchema.builder()
+        CreateCollectionReq.FieldSchema fieldFloatVector = CreateCollectionReq.FieldSchema.builder()
                 .dataType(DataType.FloatVector)
                 .name(CommonData.fieldFloatVector)
                 .isPrimaryKey(false)
                 .dimension(CommonData.dim)
                 .build();
 
-        List<CreateCollectionReq.FieldSchema> fieldSchemaList=new ArrayList<>();
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
         fieldSchemaList.add(fieldInt64);
         fieldSchemaList.add(fieldInt32);
         fieldSchemaList.add(fieldInt16);
@@ -493,7 +503,7 @@ public class CreateCollectionTest extends BaseTest {
         fieldSchemaList.add(fieldJson);
         fieldSchemaList.add(fieldVarchar);
         fieldSchemaList.add(fieldFloatVector);
-        CreateCollectionReq.CollectionSchema collectionSchema= CreateCollectionReq.CollectionSchema.builder()
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
                 .fieldSchemaList(fieldSchemaList)
                 .build();
         IndexParam indexParam = IndexParam.builder()
@@ -504,7 +514,7 @@ public class CreateCollectionTest extends BaseTest {
                 .build();
         CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
                 .collectionSchema(collectionSchema)
-                .collectionName(collectionNameWithIndex)
+                .collectionName(collectionNameWithNullAndDefault)
                 .enableDynamicField(false)
                 .indexParams(Collections.singletonList(indexParam))
                 .numShards(1)
@@ -512,12 +522,82 @@ public class CreateCollectionTest extends BaseTest {
         BaseTest.milvusClientV2.createCollection(createCollectionReq);
 
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
-        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithIndex));
+        Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithNullAndDefault));
         //insert
-        CommonFunction.generateDefaultData(0,100,CommonData.dim,DataType.FloatVector);
+        CommonFunction.generateDefaultData(0, 100, CommonData.dim, DataType.FloatVector);
         // search
-        SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithIndex);
-        Assert.assertEquals(searchResp.getSearchResults().size(),10);
+        SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithNullAndDefault);
+        Assert.assertEquals(searchResp.getSearchResults().size(), 10);
     }
 
+    @Test(description = "Create collection with properties", groups = {"Smoke"})
+    public void createCollectionWithProperties() {
+        String collection = "a"+MathUtil.getRandomString(10);
+        Map<String, String> map = new HashMap<String, String>() {{
+            put(Constant.MMAP_ENABLED, "true");
+        }};
+        CreateCollectionReq.CollectionSchema collectionSchema = CommonFunction.providerCollectionSchema(CommonData.dim, DataType.FloatVector);
+        milvusClientV2.createCollection(CreateCollectionReq.builder()
+                .collectionName(collection)
+                .properties(map)
+                .collectionSchema(collectionSchema)
+                .build());
+        DescribeCollectionResp describeCollectionResp = milvusClientV2.describeCollection(DescribeCollectionReq.builder()
+                .collectionName(collection)
+                .build());
+        Map<String, String> properties = describeCollectionResp.getProperties();
+        Assert.assertTrue(properties.containsKey(Constant.MMAP_ENABLED));
+        Assert.assertTrue(properties.get(Constant.MMAP_ENABLED).equalsIgnoreCase("true"));
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collection).build());
+    }
+
+    @Test(description = "Create collection with functions", groups = {"Smoke"})
+    public void createCollectionWithFunctions() {
+        String collection = "a"+MathUtil.getRandomString(10);
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
+                .autoID(false)
+                .dataType(io.milvus.v2.common.DataType.Int64)
+                .isPrimaryKey(true)
+                .name(CommonData.fieldInt64)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVarchar = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.VarChar)
+                .isPrimaryKey(false)
+                .name(CommonData.fieldVarchar)
+                .enableAnalyzer(true)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVector = CreateCollectionReq.FieldSchema.builder()
+                .dataType(DataType.SparseFloatVector)
+                .isPrimaryKey(false)
+//                .dimension(CommonData.dim)
+                .name(CommonData.fieldSparseVector)
+                .build();
+
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
+        fieldSchemaList.add(fieldInt64);
+        fieldSchemaList.add(fieldVarchar);
+        fieldSchemaList.add(fieldVector);
+        List<CreateCollectionReq.Function> functions = new ArrayList<>();
+        functions.add(CreateCollectionReq.Function.builder()
+                .name("varcharToFloatVector")
+                .functionType(FunctionType.BM25)
+                .inputFieldNames(Lists.newArrayList(CommonData.fieldVarchar))
+                .outputFieldNames(Lists.newArrayList(CommonData.fieldSparseVector))
+                .build());
+        CreateCollectionReq.CollectionSchema schema = CreateCollectionReq.CollectionSchema.builder()
+                .fieldSchemaList(fieldSchemaList)
+                .functionList(functions)
+                .build();
+
+        milvusClientV2.createCollection(CreateCollectionReq.builder().collectionName(collection)
+                .collectionSchema(schema)
+                .numShards(1)
+                .enableDynamicField(false)
+                .description("collection desc")
+                .build());
+
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(collection).build());
+    }
+
+
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/database/AlterDatabasePropertiesTest.java

@@ -0,0 +1,49 @@
+package com.zilliz.milvustestv2.database;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.param.Constant;
+import io.milvus.v2.service.database.request.AlterDatabasePropertiesReq;
+import io.milvus.v2.service.database.request.CreateDatabaseReq;
+import io.milvus.v2.service.database.request.DescribeDatabaseReq;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
+import io.milvus.v2.service.database.response.DescribeDatabaseResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+public class AlterDatabasePropertiesTest extends BaseTest {
+    @BeforeClass(alwaysRun = true)
+    public void initTestData(){
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder().databaseName(CommonData.databaseName).build());
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(CommonData.databaseName).build());
+    }
+
+    @Test(description = "alter database properties",groups = {"Smoke"})
+    public void alterDatabaseProperties(){
+        milvusClientV2.alterDatabaseProperties(AlterDatabasePropertiesReq.builder()
+                .databaseName(CommonData.databaseName)
+                .property(Constant.DATABASE_REPLICA_NUMBER,"2")
+                .build());
+        DescribeDatabaseResp describeDatabaseResp = milvusClientV2.describeDatabase(DescribeDatabaseReq.builder()
+                .databaseName(CommonData.databaseName).build());
+        Assert.assertEquals(describeDatabaseResp.getDatabaseName(),CommonData.databaseName);
+        Assert.assertEquals(describeDatabaseResp.getProperties().get(Constant.DATABASE_REPLICA_NUMBER),"2");
+    }
+
+    @Test(description = "alter database not existed properties",groups = {"L2"})
+    public void alterDatabaseNotExistedProperties(){
+        milvusClientV2.alterDatabaseProperties(AlterDatabasePropertiesReq.builder()
+                .databaseName(CommonData.databaseName)
+                .property("NotExisted","2")
+                .build());
+        DescribeDatabaseResp describeDatabaseResp = milvusClientV2.describeDatabase(DescribeDatabaseReq.builder()
+                .databaseName(CommonData.databaseName).build());
+        Assert.assertEquals(describeDatabaseResp.getDatabaseName(),CommonData.databaseName);
+        Assert.assertEquals(describeDatabaseResp.getProperties().get("NotExisted"),"2");
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/database/CreateDatabaseTest.java

@@ -2,9 +2,7 @@ package com.zilliz.milvustestv2.database;
 
 import com.zilliz.milvustestv2.common.BaseTest;
 import com.zilliz.milvustestv2.common.CommonData;
-import com.zilliz.milvustestv2.common.CommonFunction;
 import io.milvus.v2.common.DataType;
-import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.database.request.CreateDatabaseReq;
 import io.milvus.v2.service.database.request.DropDatabaseReq;
 import io.milvus.v2.service.database.response.ListDatabasesResp;

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/database/DropDatabasePropertiesTest.java

@@ -0,0 +1,50 @@
+package com.zilliz.milvustestv2.database;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.param.Constant;
+import io.milvus.v2.service.database.request.*;
+import io.milvus.v2.service.database.response.DescribeDatabaseResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+public class DropDatabasePropertiesTest extends BaseTest {
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder().databaseName(CommonData.databaseName).build());
+        milvusClientV2.alterDatabaseProperties(AlterDatabasePropertiesReq.builder()
+                .databaseName(CommonData.databaseName)
+                .property(Constant.DATABASE_REPLICA_NUMBER, "2")
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder().databaseName(CommonData.databaseName).build());
+    }
+
+
+    @Test(description = "drop database properties", groups = {"Smoke"})
+    public void dropDatabaseProperties() {
+        milvusClientV2.dropDatabaseProperties(DropDatabasePropertiesReq.builder()
+                .databaseName(CommonData.databaseName)
+                .propertyKeys(Lists.newArrayList(Constant.DATABASE_REPLICA_NUMBER))
+                .build());
+        DescribeDatabaseResp describeDatabaseResp = milvusClientV2.describeDatabase(DescribeDatabaseReq.builder()
+                .databaseName(CommonData.databaseName).build());
+        Assert.assertEquals(describeDatabaseResp.getDatabaseName(), CommonData.databaseName);
+        Assert.assertNull(describeDatabaseResp.getProperties().get(Constant.DATABASE_REPLICA_NUMBER));
+    }
+
+    @Test(description = "drop database not existed properties", groups = {"L2"})
+    public void dropDatabaseNotExistedProperties() {
+        milvusClientV2.dropDatabaseProperties(DropDatabasePropertiesReq.builder()
+                .databaseName(CommonData.databaseName)
+                .propertyKeys(Lists.newArrayList("not existed"))
+                .build());
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/database/ListDatabaseTest.java

@@ -0,0 +1,16 @@
+package com.zilliz.milvustestv2.database;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import io.milvus.v2.service.database.response.ListDatabasesResp;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+public class ListDatabaseTest extends BaseTest {
+    @Test(description = "list database", groups = {"Smoke"})
+    public void listDatabase() {
+        ListDatabasesResp listDatabasesResp = milvusClientV2.listDatabases();
+        Assert.assertTrue(listDatabasesResp.getDatabaseNames().contains("default"));
+    }
+
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/database/UseDatabaseTest.java

@@ -0,0 +1,84 @@
+package com.zilliz.milvustestv2.database;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import io.milvus.v2.service.database.request.CreateDatabaseReq;
+import io.milvus.v2.service.database.request.DropDatabaseReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class UseDatabaseTest extends BaseTest {
+
+    private static String collectionName = "";
+
+    @BeforeClass(alwaysRun = true)
+    public void provideTestData() {
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder()
+                .databaseName(CommonData.databaseName2).build());
+        milvusClientV2.createDatabase(CreateDatabaseReq.builder()
+                .databaseName(CommonData.databaseName1).build());
+
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        try {
+            milvusClientV2.useDatabase(CommonData.databaseName2);
+            ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
+            List<String> collectionNames = listCollectionsResp.getCollectionNames();
+            collectionNames.forEach(x->{
+                milvusClientV2.dropCollection(DropCollectionReq.builder()
+                        .collectionName(x).build());
+            });
+
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder()
+                .databaseName(CommonData.databaseName2).build());
+        milvusClientV2.dropDatabase(DropDatabaseReq.builder()
+                .databaseName(CommonData.databaseName1).build());
+        try {
+            milvusClientV2.useDatabase("default");
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test(description = "use database", groups = {"Smoke"})
+    public void testUseDatabase() {
+        try {
+            milvusClientV2.useDatabase(CommonData.databaseName2);
+            collectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+            CommonFunction.createIndexAndInsertAndLoad(collectionName, DataType.FloatVector, true, CommonData.numberEntities);
+            ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
+            Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionName));
+            // use databaseName1
+            milvusClientV2.useDatabase(CommonData.databaseName1);
+            ListCollectionsResp listCollectionsResp2 = milvusClientV2.listCollections();
+            Assert.assertFalse(listCollectionsResp2.getCollectionNames().contains(collectionName));
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test(description = "use nonexistent database", groups = {"Smoke"})
+    public void testUseNonexistentDatabase(){
+        try {
+            milvusClientV2.useDatabase("NonexistentDB");
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("not exist"));
+        }
+    }
+
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/index/AlterIndexPropertiesTest.java

@@ -0,0 +1,48 @@
+package com.zilliz.milvustestv2.index;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.param.Constant;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.index.request.AlterIndexPropertiesReq;
+import io.milvus.v2.service.index.request.DescribeIndexReq;
+import io.milvus.v2.service.index.request.ListIndexesReq;
+import io.milvus.v2.service.index.response.DescribeIndexResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class AlterIndexPropertiesTest extends BaseTest {
+    private String collectionName;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTest() {
+        collectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        CommonFunction.createIndex(collectionName, DataType.FloatVector);
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void destroyTestData() {
+        milvusClientV2.dropCollection(DropCollectionReq.builder()
+                .collectionName(collectionName).build());
+    }
+
+    @Test(description = "alter index properties", groups = {"Smoke"})
+    public void alterIndexProperties() {
+        List<String> strings = milvusClientV2.listIndexes(ListIndexesReq.builder()
+                .collectionName(collectionName).build());
+        milvusClientV2.alterIndexProperties(AlterIndexPropertiesReq.builder()
+                .collectionName(collectionName)
+                .indexName(strings.get(0))
+                .property(Constant.MMAP_ENABLED,"true").build());
+        DescribeIndexResp describeIndexResp = milvusClientV2.describeIndex(DescribeIndexReq.builder()
+                .collectionName(collectionName)
+                .indexName(strings.get(0)).build());
+        Assert.assertTrue(describeIndexResp.getIndexDescriptions().get(0).getProperties().get(Constant.MMAP_ENABLED).equalsIgnoreCase("true"));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/index/AlterIndexTest.java

@@ -51,7 +51,7 @@ public class AlterIndexTest extends BaseTest {
                 .collectionName(collectionName)
                 .indexName(strings.get(0)).build());
         System.out.println(describeIndexResp);
-        Assert.assertTrue(describeIndexResp.getIndexDescriptions().get(0).getExtraParams().get(Constant.MMAP_ENABLED).equalsIgnoreCase("true"));
+        Assert.assertTrue(describeIndexResp.getIndexDescriptions().get(0).getProperties().get(Constant.MMAP_ENABLED).equalsIgnoreCase("true"));
 
     }
 

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/index/DropIndexPropertiesTest.java

@@ -0,0 +1,57 @@
+package com.zilliz.milvustestv2.index;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.param.Constant;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.index.request.AlterIndexPropertiesReq;
+import io.milvus.v2.service.index.request.DescribeIndexReq;
+import io.milvus.v2.service.index.request.DropIndexPropertiesReq;
+import io.milvus.v2.service.index.request.ListIndexesReq;
+import io.milvus.v2.service.index.response.DescribeIndexResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class DropIndexPropertiesTest extends BaseTest {
+    private String collectionName;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTest() {
+        collectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        CommonFunction.createIndex(collectionName, DataType.FloatVector);
+        List<String> strings = milvusClientV2.listIndexes(ListIndexesReq.builder()
+                .collectionName(collectionName).build());
+        milvusClientV2.alterIndexProperties(AlterIndexPropertiesReq.builder()
+                .collectionName(collectionName)
+                .indexName(strings.get(0))
+                .property(Constant.MMAP_ENABLED, "true").build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void destroyTestData() {
+        milvusClientV2.dropCollection(DropCollectionReq.builder()
+                .collectionName(collectionName).build());
+    }
+
+    @Test(description = "drop index properties", groups = {"Smoke"})
+    public void dropIndexProperties() {
+        List<String> strings = milvusClientV2.listIndexes(ListIndexesReq.builder()
+                .collectionName(collectionName).build());
+        milvusClientV2.dropIndexProperties(DropIndexPropertiesReq.builder()
+                .indexName(strings.get(0))
+                .propertyKeys(Lists.newArrayList(Constant.MMAP_ENABLED))
+                .collectionName(collectionName)
+                .build());
+        DescribeIndexResp describeIndexResp = milvusClientV2.describeIndex(DescribeIndexReq.builder()
+                .collectionName(collectionName)
+                .indexName(strings.get(0)).build());
+        Assert.assertNull(describeIndexResp.getIndexDescriptions().get(0).getProperties().get(Constant.MMAP_ENABLED));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/GetLoadStateTest.java

@@ -0,0 +1,50 @@
+package com.zilliz.milvustestv2.loadRelease;
+
+import com.google.gson.JsonObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.GetLoadStateReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class GetLoadStateTest extends BaseTest {
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        CommonFunction.createVectorIndex(newCollectionName,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "get load state",groups = {"Smoke"})
+    public void getLoadState(){
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+        try {
+            Thread.sleep(10*1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        Boolean loadState = milvusClientV2.getLoadState(GetLoadStateReq.builder().collectionName(newCollectionName).build());
+        Assert.assertTrue(loadState);
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/LoadCollectionTest.java

@@ -6,13 +6,25 @@ import com.zilliz.milvustestv2.common.BaseTest;
 import com.zilliz.milvustestv2.common.CommonData;
 import com.zilliz.milvustestv2.common.CommonFunction;
 import com.zilliz.milvustestv2.utils.GenerateUtil;
+import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
+import io.milvus.common.resourcegroup.ResourceGroupConfig;
+import io.milvus.common.resourcegroup.ResourceGroupLimit;
+import io.milvus.common.resourcegroup.ResourceGroupTransfer;
+import io.milvus.v2.client.ConnectConfig;
+import io.milvus.v2.client.MilvusClientV2;
 import io.milvus.v2.common.ConsistencyLevel;
 import io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.collection.request.ReleaseCollectionReq;
+import io.milvus.v2.service.collection.response.ListCollectionsResp;
+import io.milvus.v2.service.resourcegroup.request.CreateResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DropResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.UpdateResourceGroupsReq;
 import io.milvus.v2.service.vector.request.InsertReq;
 import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.request.data.BaseVector;
 import io.milvus.v2.service.vector.response.SearchResp;
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
@@ -20,7 +32,9 @@ import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * @Author yongpeng.li
@@ -28,21 +42,22 @@ import java.util.List;
  */
 public class LoadCollectionTest extends BaseTest {
     String newCollectionName;
+
     @BeforeClass(alwaysRun = true)
-    public void providerCollection(){
+    public void providerCollection() {
         newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
-        CommonFunction.createVectorIndex(newCollectionName,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+        CommonFunction.createVectorIndex(newCollectionName, CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
     }
 
     @AfterClass(alwaysRun = true)
-    public void cleanTestData(){
+    public void cleanTestData() {
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
     }
 
-    @Test(description = "Load collection",groups = {"Smoke"})
-    public void loadCollection(){
+    @Test(description = "Load collection", groups = {"Smoke"})
+    public void loadCollection() {
         milvusClientV2.loadCollection(LoadCollectionReq.builder()
                 .collectionName(newCollectionName)
                 .build());
@@ -50,5 +65,130 @@ public class LoadCollectionTest extends BaseTest {
         Assert.assertEquals(searchResp.getSearchResults().size(), CommonData.topK);
     }
 
+    @Test(description = "Load collection with partial field", groups = {"Smoke"})
+    public void loadCollectionWithPartialField() {
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .loadFields(Lists.newArrayList(CommonData.fieldInt64, CommonData.fieldInt32, CommonData.fieldFloatVector))
+                .build());
+        List<BaseVector> baseVectors = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(newCollectionName)
+                .topK(CommonData.topK)
+                .annsField(CommonData.fieldFloatVector)
+                .outputFields(Lists.newArrayList(CommonData.fieldInt32))
+                .data(baseVectors)
+                .build());
+        Assert.assertEquals(search.getSearchResults().get(0).size(), CommonData.topK);
+    }
+
+    @Test(description = "search when the field not  loaded", groups = {"Smoke"})
+    public void searchWhenTheFieldNotLoaded() {
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .loadFields(Lists.newArrayList(CommonData.fieldInt64, CommonData.fieldInt32, CommonData.fieldFloatVector))
+                .build());
+        List<BaseVector> baseVectors = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
+        try {
+            SearchResp search = milvusClientV2.search(SearchReq.builder()
+                    .collectionName(newCollectionName)
+                    .topK(CommonData.topK)
+                    .annsField(CommonData.fieldFloatVector)
+                    .outputFields(Lists.newArrayList(CommonData.fieldInt16))
+                    .data(baseVectors)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("not loaded"));
+        }
+    }
+
+    @Test(description = "Load need contains pk field", groups = {"Smoke"})
+    public void loadNeedContainsPrimaryKey() {
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        try {
+            milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                    .collectionName(newCollectionName)
+                    .loadFields(Lists.newArrayList(CommonData.fieldInt32, CommonData.fieldFloatVector))
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("does not contain primary key field"));
+        }
+    }
+
+    @Test(description = "Load need contains vector field", groups = {"Smoke"})
+    public void loadNeedContainsVectorField() {
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        try {
+            milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                    .collectionName(newCollectionName)
+                    .loadFields(Lists.newArrayList(CommonData.fieldInt32, CommonData.fieldInt64))
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("does not contain vector field"));
+        }
+    }
+
+    @Test(description = "Load with resource group", groups = {"Smoke"})
+    public void loadWithResourceGroup() {
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        // 创建resource group
+        ResourceGroupLimit resourceGroupLimit = new ResourceGroupLimit(2);
+        ResourceGroupLimit resourceGroupRequest = new ResourceGroupLimit(1);
+        milvusClientV2.createResourceGroup(CreateResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .config(ResourceGroupConfig.newBuilder()
+                        .withLimits(resourceGroupLimit)
+                        .withRequests(resourceGroupRequest)
+                        .build()).build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .resourceGroups(Lists.newArrayList(CommonData.resourceGroup))
+                .build());
+        List<BaseVector> baseVectors = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(newCollectionName)
+                .topK(CommonData.topK)
+                .annsField(CommonData.fieldFloatVector)
+                .outputFields(Lists.newArrayList(CommonData.fieldInt32))
+                .data(baseVectors)
+                .build());
+        Assert.assertEquals(search.getSearchResults().get(0).size(), CommonData.topK);
+        // release collection + drop resourceGroup
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        ResourceGroupConfig resourceGroupConfig = ResourceGroupConfig.newBuilder().withRequests(new ResourceGroupLimit(0))
+                .withLimits(new ResourceGroupLimit(0)).build();
+        Map<String, ResourceGroupConfig> resourceGroups = new HashMap<>();
+        resourceGroups.put(CommonData.resourceGroup, resourceGroupConfig);
+        milvusClientV2.updateResourceGroups(UpdateResourceGroupsReq.builder().resourceGroups(resourceGroups).build());
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .build());
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .build());
+    }
+
+    @Test(description = "Load with replica nul", groups = {"Cluster","L1"})
+    public void loadWithReplicaNum() {
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .numReplicas(1)
+                .build());
+
+        List<BaseVector> baseVectors = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(newCollectionName)
+                .topK(CommonData.topK)
+                .annsField(CommonData.fieldFloatVector)
+                .outputFields(Lists.newArrayList(CommonData.fieldInt32))
+                .data(baseVectors)
+                .build());
+        Assert.assertEquals(search.getSearchResults().get(0).size(), CommonData.topK);
+    }
+
 
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/LoadPartitionsTest.java

@@ -10,6 +10,7 @@ import io.milvus.v2.common.ConsistencyLevel;
 import io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.GetLoadStateReq;
 import io.milvus.v2.service.collection.request.LoadCollectionReq;
 import io.milvus.v2.service.partition.request.CreatePartitionReq;
 import io.milvus.v2.service.partition.request.LoadPartitionsReq;
@@ -43,17 +44,18 @@ public class LoadPartitionsTest extends BaseTest {
                 .collectionName(newCollection)
                 .partitionName(CommonData.partitionName)
                 .build());
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollection).partitionName(CommonData.partitionName).data(jsonObjects).build());
-        CommonFunction.createVectorIndex(newCollection,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+        CommonFunction.createVectorIndex(newCollection, CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
     }
+
     @AfterClass(alwaysRun = true)
-    public void cleanTestData(){
+    public void cleanTestData() {
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
     }
 
-    @Test(description = "Load partition",groups = {"Smoke"})
-    public void loadPartition(){
+    @Test(description = "Load partition", groups = {"Smoke"})
+    public void loadPartition() {
         milvusClientV2.loadPartitions(LoadPartitionsReq.builder()
                 .collectionName(newCollection)
                 .partitionNames(Collections.singletonList(CommonData.partitionName))
@@ -61,7 +63,9 @@ public class LoadPartitionsTest extends BaseTest {
 
         List<List<Float>> vectors = GenerateUtil.generateFloatVector(10, 3, CommonData.dim);
         List<BaseVector> data = new ArrayList<>();
-        vectors.forEach((v)->{data.add(new FloatVec(v));});
+        vectors.forEach((v) -> {
+            data.add(new FloatVec(v));
+        });
         SearchResp searchResp = milvusClientV2.search(SearchReq.builder()
                 .collectionName(newCollection)
                 .outputFields(Lists.newArrayList("*"))
@@ -73,4 +77,11 @@ public class LoadPartitionsTest extends BaseTest {
                 .build());
         Assert.assertEquals(searchResp.getSearchResults().size(), CommonData.topK);
     }
+
+    @Test(description = "get load state by partition", groups = "Smoke", dependsOnMethods = {"loadPartition"})
+    public void getLoadStateByPartition() {
+        Boolean loadState = milvusClientV2.getLoadState(GetLoadStateReq.builder().collectionName(newCollection)
+                .partitionName(CommonData.partitionName).build());
+        Assert.assertTrue(loadState);
+    }
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/loadRelease/RefreshLoadTest.java

@@ -0,0 +1,63 @@
+package com.zilliz.milvustestv2.loadRelease;
+
+import com.google.gson.JsonObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.*;
+import io.milvus.v2.service.vector.request.InsertReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class RefreshLoadTest extends BaseTest {
+
+    String newCollectionName;
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection(){
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        CommonFunction.createVectorIndex(newCollectionName,CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "refresh load collection",groups = {"Smoke"})
+    public void refreshLoadTest(){
+        milvusClientV2.refreshLoad(RefreshLoadReq.builder().collectionName(newCollectionName)
+                .build());
+        try {
+            Thread.sleep(10*1000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        Boolean loadState = milvusClientV2.getLoadState(GetLoadStateReq.builder().collectionName(newCollectionName).build());
+        Assert.assertTrue(loadState);
+    }
+
+    @Test(description = "refresh load collection where the collection not loaded",groups ={"L1"})
+    public void refreshLoadUnloadedCollection(){
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder()
+                .collectionName(newCollectionName).build());
+        try {
+            milvusClientV2.refreshLoad(RefreshLoadReq.builder().collectionName(newCollectionName)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("collection not loaded"));
+        }
+
+    }
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/others/CompactTest.java

@@ -0,0 +1,38 @@
+package com.zilliz.milvustestv2.others;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.utils.MathUtil;
+import io.milvus.v2.service.utility.request.CompactReq;
+import io.milvus.v2.service.utility.response.CompactResp;
+import lombok.extern.slf4j.Slf4j;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+@Slf4j
+public class CompactTest extends BaseTest {
+
+    @Test(description = "Compact", groups = {"Smoke"})
+    public void compactTest() {
+        CompactResp compact = milvusClientV2.compact(CompactReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .build());
+        Long compactionID = compact.getCompactionID();
+        Assert.assertNotNull(compactionID);
+
+    }
+
+    @Test(description = "Compact not existed collection", groups = {"Smoke"})
+    public void compactNotExistedColTest() {
+        String collectionName="a"+MathUtil.getRandomString(10);
+        try {
+            CompactResp compact = milvusClientV2.compact(CompactReq.builder()
+                    .collectionName(collectionName)
+                    .build());
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+            Assert.assertTrue(e.getMessage().contains("can't find"));
+        }
+
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/others/FlushTest.java

@@ -0,0 +1,35 @@
+package com.zilliz.milvustestv2.others;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import com.zilliz.milvustestv2.utils.MathUtil;
+import io.milvus.v2.service.utility.request.FlushReq;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Random;
+
+public class FlushTest extends BaseTest {
+
+    @Test(description = "flush", groups = {"Smoke"})
+    public void flushTest() {
+        milvusClientV2.flush(FlushReq.builder()
+                .collectionNames(Lists.newArrayList(CommonData.defaultFloatVectorCollection))
+                .waitFlushedTimeoutMs(60 * 1000L)
+                .build());
+    }
+
+    @Test(description = "flush not existed collection", groups = {"Smoke"})
+    public void flushNotExistedCollectionTest() {
+        try {
+            milvusClientV2.flush(FlushReq.builder()
+                    .collectionNames(Lists.newArrayList("a"+MathUtil.getRandomString(5)))
+                    .waitFlushedTimeoutMs(60 * 1000L)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("collection not found"));
+        }
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/others/GetCompactionStateTest.java

@@ -0,0 +1,38 @@
+package com.zilliz.milvustestv2.others;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.v2.common.CompactionState;
+import io.milvus.v2.service.utility.request.CompactReq;
+import io.milvus.v2.service.utility.request.GetCompactionStateReq;
+import io.milvus.v2.service.utility.response.CompactResp;
+import io.milvus.v2.service.utility.response.GetCompactionStateResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+public class GetCompactionStateTest extends BaseTest {
+
+    Long compactionID;
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        CompactResp compact = milvusClientV2.compact(CompactReq.builder()
+                .collectionName(CommonData.defaultFloatVectorCollection)
+                .build());
+        compactionID = compact.getCompactionID();
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+
+    }
+
+    @Test(description = "get compact state", groups = {"Smoke"})
+    public void getCompactState() {
+        GetCompactionStateResp compactionState = milvusClientV2.getCompactionState(GetCompactionStateReq.builder()
+                .compactionID(compactionID).build());
+        Assert.assertEquals(compactionState.getState(), CompactionState.Completed);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/others/GetServerVersionTest.java

@@ -0,0 +1,14 @@
+package com.zilliz.milvustestv2.others;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+public class GetServerVersionTest extends BaseTest {
+
+    @Test(description = "get server version", groups = {"Smoke"})
+    public void getServerVersion() {
+        String serverVersion = milvusClientV2.getServerVersion();
+        Assert.assertTrue(serverVersion.contains("v"));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/partition/GetPartitionStatsTest.java

@@ -0,0 +1,88 @@
+package com.zilliz.milvustestv2.partition;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.partition.request.GetPartitionStatsReq;
+import io.milvus.v2.service.partition.response.GetPartitionStatsResp;
+import io.milvus.v2.service.utility.request.FlushReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.response.InsertResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+public class GetPartitionStatsTest extends BaseTest {
+
+    String floatVectorCollection;
+    String sparseFloatVectorCollection;
+    String float16VectorCollection;
+    String bFloat16VectorCollection;
+    String binaryVectorCollection;
+
+    @DataProvider(name = "initCollection")
+    public Object[][] providerCollection() {
+        floatVectorCollection = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(floatVectorCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+
+        sparseFloatVectorCollection = CommonFunction.createNewCollection(CommonData.dim, null, DataType.SparseFloatVector);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(sparseFloatVectorCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        float16VectorCollection = CommonFunction.createNewCollection(CommonData.dim, null, DataType.Float16Vector);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(float16VectorCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        bFloat16VectorCollection = CommonFunction.createNewCollection(CommonData.dim, null, DataType.BFloat16Vector);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(bFloat16VectorCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        binaryVectorCollection = CommonFunction.createNewCollection(CommonData.dim, null, DataType.BinaryVector);
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(binaryVectorCollection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        return new Object[][]{
+                {floatVectorCollection},
+                {sparseFloatVectorCollection},
+                {float16VectorCollection},
+                {bFloat16VectorCollection},
+                {binaryVectorCollection},
+        };
+    }
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData(){
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(floatVectorCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(sparseFloatVectorCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(float16VectorCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(bFloat16VectorCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(binaryVectorCollection).build());
+    }
+
+    @Test(description = "get partition stats",dataProvider = "initCollection")
+    public void getPartitionStatsTest(String collection) throws InterruptedException {
+        // insert
+        InsertResp insert = milvusClientV2.insert(InsertReq.builder().collectionName(collection)
+                .partitionName(CommonData.partitionName)
+                .data(CommonFunction.genCommonData(collection, CommonData.numberEntities)).build());
+        milvusClientV2.flush(FlushReq.builder().collectionNames(Lists.newArrayList(collection)).build());
+        GetPartitionStatsResp partitionStats = milvusClientV2.getPartitionStats(GetPartitionStatsReq.builder()
+                .collectionName(collection)
+                .partitionName(CommonData.partitionName)
+                .build());
+        Assert.assertEquals(partitionStats.getNumOfEntities(),CommonData.numberEntities);
+
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/resourceGroup/CreateResourceGroupTest.java

@@ -0,0 +1,108 @@
+package com.zilliz.milvustestv2.resourceGroup;
+
+import com.google.common.collect.Lists;
+import com.google.gson.JsonObject;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.common.resourcegroup.ResourceGroupConfig;
+import io.milvus.common.resourcegroup.ResourceGroupLimit;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.collection.request.ReleaseCollectionReq;
+import io.milvus.v2.service.resourcegroup.request.CreateResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DescribeResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DropResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.UpdateResourceGroupsReq;
+import io.milvus.v2.service.resourcegroup.response.DescribeResourceGroupResp;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.request.SearchReq;
+import io.milvus.v2.service.vector.request.data.BaseVector;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class CreateResourceGroupTest extends BaseTest {
+    String newCollectionName;
+
+    @BeforeClass(alwaysRun = true)
+    public void providerCollection() {
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
+        milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
+        CommonFunction.createVectorIndex(newCollectionName, CommonData.fieldFloatVector, IndexParam.IndexType.HNSW, IndexParam.MetricType.L2);
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
+    }
+
+    @Test(description = "create resource group", groups = {"Smoke"})
+    public void createResourceGroup() {
+        ResourceGroupLimit resourceGroupLimit = new ResourceGroupLimit(2);
+        ResourceGroupLimit resourceGroupRequest = new ResourceGroupLimit(1);
+        milvusClientV2.createResourceGroup(CreateResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .config(ResourceGroupConfig.newBuilder()
+                        .withLimits(resourceGroupLimit)
+                        .withRequests(resourceGroupRequest)
+                        .build()).build());
+        DescribeResourceGroupResp describeResourceGroupResp = milvusClientV2.describeResourceGroup(DescribeResourceGroupReq.builder().groupName(CommonData.resourceGroup).build());
+        Assert.assertEquals(describeResourceGroupResp.getNumberOfAvailableNode(),1);
+        Assert.assertEquals(describeResourceGroupResp.getConfig().getRequests().getNodeNum(),1);
+        Assert.assertNotNull(describeResourceGroupResp.getNodes().get(0).getAddress());
+        // clean data
+        ResourceGroupConfig resourceGroupConfig = ResourceGroupConfig.newBuilder().withRequests(new ResourceGroupLimit(0))
+                .withLimits(new ResourceGroupLimit(0)).build();
+        Map<String, ResourceGroupConfig> resourceGroups = new HashMap<>();
+        resourceGroups.put(CommonData.resourceGroup, resourceGroupConfig);
+        milvusClientV2.updateResourceGroups(UpdateResourceGroupsReq.builder().resourceGroups(resourceGroups).build());
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .build());
+    }
+
+    @Test(description = "create resource group exceeds maximum resource", groups = {"L1"})
+    public void createResourceGroupExceedMax() {
+        ResourceGroupLimit resourceGroupLimit = new ResourceGroupLimit(20);
+        ResourceGroupLimit resourceGroupRequest = new ResourceGroupLimit(10);
+        milvusClientV2.createResourceGroup(CreateResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup2)
+                .config(ResourceGroupConfig.newBuilder()
+                        .withLimits(resourceGroupLimit)
+                        .withRequests(resourceGroupRequest)
+                        .build()).build());
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(newCollectionName)
+                .resourceGroups(Lists.newArrayList(CommonData.resourceGroup2))
+                .build());
+        List<BaseVector> baseVectors = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(newCollectionName)
+                .topK(CommonData.topK)
+                .annsField(CommonData.fieldFloatVector)
+                .outputFields(Lists.newArrayList(CommonData.fieldInt32))
+                .data(baseVectors)
+                .build());
+        Assert.assertEquals(search.getSearchResults().get(0).size(), CommonData.topK);
+        // release collection + drop resourceGroup
+        milvusClientV2.releaseCollection(ReleaseCollectionReq.builder().collectionName(newCollectionName).build());
+        ResourceGroupConfig resourceGroupConfig = ResourceGroupConfig.newBuilder().withRequests(new ResourceGroupLimit(0))
+                .withLimits(new ResourceGroupLimit(0)).build();
+        Map<String, ResourceGroupConfig> resourceGroups2 = new HashMap<>();
+        resourceGroups2.put(CommonData.resourceGroup2, resourceGroupConfig);
+        milvusClientV2.updateResourceGroups(UpdateResourceGroupsReq.builder().resourceGroups(resourceGroups2).build());
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup2)
+                .build());
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/resourceGroup/DescribeResourceGroupTest.java

@@ -0,0 +1,58 @@
+package com.zilliz.milvustestv2.resourceGroup;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.common.resourcegroup.ResourceGroupConfig;
+import io.milvus.common.resourcegroup.ResourceGroupLimit;
+import io.milvus.v2.service.resourcegroup.request.CreateResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DescribeResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DropResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.UpdateResourceGroupsReq;
+import io.milvus.v2.service.resourcegroup.response.DescribeResourceGroupResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class DescribeResourceGroupTest extends BaseTest {
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        ResourceGroupLimit resourceGroupLimit = new ResourceGroupLimit(2);
+        ResourceGroupLimit resourceGroupRequest = new ResourceGroupLimit(1);
+        milvusClientV2.createResourceGroup(CreateResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .config(ResourceGroupConfig.newBuilder()
+                        .withLimits(resourceGroupLimit)
+                        .withRequests(resourceGroupRequest)
+                        .build()).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        ResourceGroupConfig resourceGroupConfig = ResourceGroupConfig.newBuilder().withRequests(new ResourceGroupLimit(0))
+                .withLimits(new ResourceGroupLimit(0)).build();
+        Map<String, ResourceGroupConfig> resourceGroups = new HashMap<>();
+        resourceGroups.put(CommonData.resourceGroup, resourceGroupConfig);
+        milvusClientV2.updateResourceGroups(UpdateResourceGroupsReq.builder().resourceGroups(resourceGroups).build());
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .build());
+    }
+
+    @Test(description = "", groups = {"Smoke"})
+    public void describeResourceGroup() {
+        DescribeResourceGroupResp describeResourceGroupResp =
+                milvusClientV2.describeResourceGroup(DescribeResourceGroupReq.builder()
+                        .groupName(CommonData.resourceGroup)
+                        .build());
+        Assert.assertEquals(describeResourceGroupResp.getNumberOfAvailableNode(),1);
+        Assert.assertEquals(describeResourceGroupResp.getConfig().getRequests().getNodeNum(),1);
+        Assert.assertNotNull(describeResourceGroupResp.getNodes().get(0).getAddress());
+    }
+
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/resourceGroup/DropResourceGroupsTest.java

@@ -0,0 +1,63 @@
+package com.zilliz.milvustestv2.resourceGroup;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.common.resourcegroup.ResourceGroupConfig;
+import io.milvus.common.resourcegroup.ResourceGroupLimit;
+import io.milvus.v2.service.resourcegroup.request.CreateResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DropResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.UpdateResourceGroupsReq;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class DropResourceGroupsTest extends BaseTest {
+
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        ResourceGroupLimit resourceGroupLimit = new ResourceGroupLimit(2);
+        ResourceGroupLimit resourceGroupRequest = new ResourceGroupLimit(1);
+        milvusClientV2.createResourceGroup(CreateResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .config(ResourceGroupConfig.newBuilder()
+                        .withLimits(resourceGroupLimit)
+                        .withRequests(resourceGroupRequest)
+                        .build()).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+
+    }
+
+    @Test(description = "drop resource group need set node num=0", groups = {"Smoke"})
+    public void dropResourceGroupBeforeChangeNodeNum() {
+        try {
+            milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                    .groupName(CommonData.resourceGroup)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("num is not 0"));
+        }
+
+    }
+
+    @Test(description = "drop resource group", groups = {"Smoke"},dependsOnMethods = {"dropResourceGroupBeforeChangeNodeNum"})
+    public void dropResourceGroup() {
+        // clean data
+        ResourceGroupConfig resourceGroupConfig = ResourceGroupConfig.newBuilder().withRequests(new ResourceGroupLimit(0))
+                .withLimits(new ResourceGroupLimit(0)).build();
+        Map<String, ResourceGroupConfig> resourceGroups = new HashMap<>();
+        resourceGroups.put(CommonData.resourceGroup, resourceGroupConfig);
+        milvusClientV2.updateResourceGroups(UpdateResourceGroupsReq.builder().resourceGroups(resourceGroups).build());
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .build());
+    }
+
+
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/resourceGroup/ListResourceGroupTest.java

@@ -0,0 +1,52 @@
+package com.zilliz.milvustestv2.resourceGroup;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.common.resourcegroup.ResourceGroupConfig;
+import io.milvus.common.resourcegroup.ResourceGroupLimit;
+import io.milvus.v2.service.resourcegroup.request.CreateResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DropResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.ListResourceGroupsReq;
+import io.milvus.v2.service.resourcegroup.request.UpdateResourceGroupsReq;
+import io.milvus.v2.service.resourcegroup.response.ListResourceGroupsResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ListResourceGroupTest extends BaseTest {
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        ResourceGroupLimit resourceGroupLimit = new ResourceGroupLimit(2);
+        ResourceGroupLimit resourceGroupRequest = new ResourceGroupLimit(1);
+        milvusClientV2.createResourceGroup(CreateResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .config(ResourceGroupConfig.newBuilder()
+                        .withLimits(resourceGroupLimit)
+                        .withRequests(resourceGroupRequest)
+                        .build()).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        ResourceGroupConfig resourceGroupConfig = ResourceGroupConfig.newBuilder().withRequests(new ResourceGroupLimit(0))
+                .withLimits(new ResourceGroupLimit(0)).build();
+        Map<String, ResourceGroupConfig> resourceGroups = new HashMap<>();
+        resourceGroups.put(CommonData.resourceGroup, resourceGroupConfig);
+        milvusClientV2.updateResourceGroups(UpdateResourceGroupsReq.builder().resourceGroups(resourceGroups).build());
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .build());
+    }
+
+    @Test(description = "List resource group ", groups = {"Smoke"})
+    public void listResourceGroup() {
+        ListResourceGroupsResp listResourceGroupsResp = milvusClientV2.listResourceGroups(ListResourceGroupsReq.builder().build());
+        System.out.println(listResourceGroupsResp.getGroupNames());
+        Assert.assertEquals(listResourceGroupsResp.getGroupNames().size(),2);
+        Assert.assertTrue(listResourceGroupsResp.getGroupNames().contains(CommonData.defaultResourceGroup));
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/resourceGroup/UpdateResourceGroupsTest.java

@@ -0,0 +1,57 @@
+package com.zilliz.milvustestv2.resourceGroup;
+
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.common.resourcegroup.ResourceGroupConfig;
+import io.milvus.common.resourcegroup.ResourceGroupLimit;
+import io.milvus.v2.service.resourcegroup.request.CreateResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DescribeResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.DropResourceGroupReq;
+import io.milvus.v2.service.resourcegroup.request.UpdateResourceGroupsReq;
+import io.milvus.v2.service.resourcegroup.response.DescribeResourceGroupResp;
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class UpdateResourceGroupsTest extends BaseTest {
+    @BeforeClass(alwaysRun = true)
+    public void initTestData() {
+        ResourceGroupLimit resourceGroupLimit = new ResourceGroupLimit(2);
+        ResourceGroupLimit resourceGroupRequest = new ResourceGroupLimit(1);
+        milvusClientV2.createResourceGroup(CreateResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .config(ResourceGroupConfig.newBuilder()
+                        .withLimits(resourceGroupLimit)
+                        .withRequests(resourceGroupRequest)
+                        .build()).build());
+    }
+
+    @AfterClass(alwaysRun = true)
+    public void cleanTestData() {
+        milvusClientV2.dropResourceGroup(DropResourceGroupReq.builder()
+                .groupName(CommonData.resourceGroup)
+                .build());
+    }
+
+    @Test(description = "update resource group", groups = {"Smoke"})
+    public void updateResourceGroup() {
+        ResourceGroupConfig resourceGroupConfig = ResourceGroupConfig.newBuilder()
+                .withRequests(new ResourceGroupLimit(0))
+                .withLimits(new ResourceGroupLimit(0))
+                .build();
+        Map<String, ResourceGroupConfig> resourceGroups = new HashMap<>();
+        resourceGroups.put(CommonData.resourceGroup, resourceGroupConfig);
+        milvusClientV2.updateResourceGroups(UpdateResourceGroupsReq.builder().resourceGroups(resourceGroups).build());
+        DescribeResourceGroupResp describeResourceGroupResp =
+                milvusClientV2.describeResourceGroup(DescribeResourceGroupReq.builder()
+                        .groupName(CommonData.resourceGroup)
+                        .build());
+        Assert.assertEquals(describeResourceGroupResp.getNumberOfAvailableNode(),0);
+        Assert.assertEquals(describeResourceGroupResp.getConfig().getRequests().getNodeNum(),0);
+        Assert.assertEquals(describeResourceGroupResp.getNodes().size(), 0);
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/DeleteTest.java

@@ -18,7 +18,6 @@ import io.milvus.v2.service.vector.request.data.BaseVector;
 import io.milvus.v2.service.vector.response.DeleteResp;
 import io.milvus.v2.service.vector.response.QueryResp;
 import io.milvus.v2.service.vector.response.SearchResp;
-import org.apache.hadoop.yarn.webapp.hamlet2.Hamlet;
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/InsertTest.java

@@ -38,7 +38,7 @@ public class InsertTest extends BaseTest {
     @BeforeClass(alwaysRun = true)
     public void providerCollection() {
         newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
-        simpleCollectionName = CommonFunction.createSimpleCollection(CommonData.dim, null);
+        simpleCollectionName = CommonFunction.createSimpleCollection(CommonData.dim, null,false);
         nullableDefaultCollectionName = CommonFunction.createNewNullableDefaultValueCollection(CommonData.dim, null, DataType.FloatVector);
     }
     @AfterClass(alwaysRun = true)

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/QueryIteratorTest.java

@@ -0,0 +1,49 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import io.milvus.orm.iterator.QueryIterator;
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.vector.request.QueryIteratorReq;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+public class QueryIteratorTest extends BaseTest {
+    @DataProvider(name = "VectorTypeList")
+    public Object[][] providerVectorType() {
+        return new Object[][]{
+                {CommonData.defaultFloatVectorCollection, DataType.FloatVector, CommonData.fieldFloatVector},
+                {CommonData.defaultBinaryVectorCollection, DataType.BinaryVector, CommonData.fieldBinaryVector},
+                {CommonData.defaultFloat16VectorCollection, DataType.Float16Vector, CommonData.fieldFloat16Vector},
+                {CommonData.defaultBFloat16VectorCollection, DataType.BFloat16Vector, CommonData.fieldBF16Vector},
+                {CommonData.defaultSparseFloatVectorCollection, DataType.SparseFloatVector, CommonData.fieldSparseVector},
+        };
+    }
+
+
+    @Test(description = "Query iterator", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void queryIteratorTest(String collection, DataType vectorType, String vectorField) {
+        QueryIterator queryIterator = milvusClientV2.queryIterator(QueryIteratorReq.builder()
+                .collectionName(collection)
+                .batchSize(10)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+                .limit(1000)
+                .build());
+        int i = 0;
+        int size;
+        do {
+            size = queryIterator.next().size();
+            i++;
+        } while (size > 0);
+        if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertEquals(i, 101);
+        }else {
+            Assert.assertTrue(i>0);
+        }
+
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/SearchIteratorTest.java

@@ -0,0 +1,90 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.common.BaseTest;
+import com.zilliz.milvustestv2.common.CommonData;
+import com.zilliz.milvustestv2.common.CommonFunction;
+import io.milvus.orm.iterator.SearchIterator;
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.vector.request.SearchIteratorReq;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+
+public class SearchIteratorTest extends BaseTest {
+
+    @DataProvider(name = "VectorTypeList")
+    public Object[][] providerVectorType() {
+        return new Object[][]{
+                {CommonData.defaultFloatVectorCollection, DataType.FloatVector, CommonData.fieldFloatVector},
+                {CommonData.defaultBinaryVectorCollection, DataType.BinaryVector, CommonData.fieldBinaryVector},
+                {CommonData.defaultFloat16VectorCollection, DataType.Float16Vector, CommonData.fieldFloat16Vector},
+                {CommonData.defaultBFloat16VectorCollection, DataType.BFloat16Vector, CommonData.fieldBF16Vector},
+                {CommonData.defaultSparseFloatVectorCollection, DataType.SparseFloatVector, CommonData.fieldSparseVector},
+        };
+    }
+
+    @Test(description = "search iterator test with expr", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchIteratorTestWithExpr(String collection, DataType vectorType, String vectorName) {
+        SearchIterator searchIterator = milvusClientV2.searchIterator(SearchIteratorReq.builder()
+                .collectionName(collection)
+                .batchSize(CommonData.batchSize)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+//                .params("{\"range_filter\": 15.0, \"radius\": 20.0}")
+                .expr(CommonData.fieldInt64 + "< 10 ")
+                .metricType(CommonFunction.provideMetricTypeByVectorType(vectorType))
+                .vectors(CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType))
+                .vectorFieldName(vectorName)
+                .batchSize(10)
+                .build());
+        if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertEquals(searchIterator.next().size(), 10);
+        }
+
+    }
+
+    @Test(description = "search iterator test2", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchIteratorTest(String collection, DataType vectorType, String vectorName) {
+        SearchIterator searchIterator = milvusClientV2.searchIterator(SearchIteratorReq.builder()
+                .collectionName(collection)
+                .batchSize(CommonData.batchSize)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+//                .params("{\"range_filter\": 15.0, \"radius\": 20.0}")
+//                .expr(CommonData.fieldInt64 + "< 10 ")
+                .metricType(CommonFunction.provideMetricTypeByVectorType(vectorType))
+                .vectors(CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType))
+                .vectorFieldName(vectorName)
+                .topK(10000)
+                .build());
+        if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertEquals(searchIterator.next().size(), 1000);
+        } else {
+            Assert.assertTrue(searchIterator.next().size() > 1);
+        }
+    }
+
+    @Test(description = "search iterator with error range filter", groups = {"L2"})
+    public void searchIteratorWithErrorRangeFilter() {
+        try {
+            SearchIterator searchIterator = milvusClientV2.searchIterator(SearchIteratorReq.builder()
+                    .collectionName(CommonData.defaultFloatVectorCollection)
+                    .batchSize(CommonData.batchSize)
+                    .consistencyLevel(ConsistencyLevel.STRONG)
+                    .outputFields(Lists.newArrayList("*"))
+                    .params("{\"range_filter\": 25.0, \"radius\": 20.0}")
+                    //                .expr(CommonData.fieldInt64 + "< 10 ")
+                    .metricType(CommonFunction.provideMetricTypeByVectorType(DataType.FloatVector))
+                    .vectors(CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector))
+                    .vectorFieldName(CommonData.fieldFloatVector)
+                    .topK(10000)
+                    .build());
+        } catch (Exception e) {
+            Assert.assertTrue(e.getMessage().contains("radius must be larger than range_filter"));
+        }
+
+    }
+}

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/SearchTest.java

@@ -7,32 +7,16 @@ import com.zilliz.milvustestv2.common.CommonData;
 import com.zilliz.milvustestv2.common.CommonFunction;
 import com.zilliz.milvustestv2.params.FieldParam;
 import com.zilliz.milvustestv2.utils.DataProviderUtils;
-import com.zilliz.milvustestv2.utils.GenerateUtil;
-import com.zilliz.milvustestv2.utils.MathUtil;
 import io.milvus.client.MilvusServiceClient;
-import io.milvus.grpc.FlushResponse;
-import io.milvus.grpc.SearchResults;
-import io.milvus.param.ConnectParam;
-import io.milvus.param.R;
-import io.milvus.param.collection.FlushParam;
-import io.milvus.param.dml.SearchParam;
 import io.milvus.v2.common.ConsistencyLevel;
 import io.milvus.v2.common.DataType;
-import io.milvus.v2.service.collection.request.DescribeCollectionReq;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
-import io.milvus.v2.service.collection.request.GetCollectionStatsReq;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.*;
-import io.milvus.v2.service.collection.response.DescribeCollectionResp;
-import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
 import io.milvus.v2.service.index.request.CreateIndexReq;
 import io.milvus.v2.service.vector.request.InsertReq;
-import io.milvus.v2.service.vector.request.QueryReq;
 import io.milvus.v2.service.vector.request.SearchReq;
 import io.milvus.v2.service.vector.request.data.BaseVector;
-import io.milvus.v2.service.vector.request.data.FloatVec;
-import io.milvus.v2.service.vector.response.InsertResp;
-import io.milvus.v2.service.vector.response.QueryResp;
 import io.milvus.v2.service.vector.response.SearchResp;
 import lombok.extern.slf4j.Slf4j;
 import org.testng.Assert;
@@ -41,10 +25,7 @@ import org.testng.annotations.BeforeClass;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * @Author yongpeng.li
@@ -161,15 +142,15 @@ public class SearchTest extends BaseTest {
     @BeforeClass(alwaysRun = true)
     public void providerCollection() {
         newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0,CommonData.numberEntities * 10, CommonData.dim, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(0, CommonData.numberEntities * 10, CommonData.dim, DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
         nullableDefaultCollectionName = CommonFunction.createNewNullableDefaultValueCollection(CommonData.dim, null, DataType.FloatVector);
         // insert data
-        List<JsonObject> jsonNullableObjects = CommonFunction.generateSimpleNullData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        List<JsonObject> jsonNullableObjects = CommonFunction.generateSimpleNullData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(nullableDefaultCollectionName).data(jsonNullableObjects).build());
         // create partition
-        CommonFunction.createPartition(nullableDefaultCollectionName,CommonData.partitionNameA);
-        List<JsonObject> jsonObjectsA = CommonFunction.generateSimpleNullData(0,CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        CommonFunction.createPartition(nullableDefaultCollectionName, CommonData.partitionNameA);
+        List<JsonObject> jsonObjectsA = CommonFunction.generateSimpleNullData(0, CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(nullableDefaultCollectionName).partitionName(CommonData.partitionNameA).data(jsonObjectsA).build());
     }
 
@@ -395,4 +376,126 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
+
+    @Test(description = "search by group size", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchByGroupSize(String collectionName, DataType vectorType) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(collectionName)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .groupByFieldName(CommonData.fieldInt8)
+                .groupSize(CommonData.groupSize)
+                .data(data)
+                .topK(1000)
+                .build());
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertTrue(search.getSearchResults().get(0).size() > 127);
+        }
+    }
+
+    @Test(description = "search by group size and topK", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchByGroupSizeAndTopK(String collectionName, DataType vectorType) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(collectionName)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .groupByFieldName(CommonData.fieldInt8)
+                .groupSize(CommonData.groupSize)
+                .data(data)
+                .topK(10)
+                .build());
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertTrue(search.getSearchResults().get(0).size() >= 10);
+        }
+    }
+
+    @Test(description = "search by group size and topK and strict", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchByGroupSizeAndTopKAndStrict(String collectionName, DataType vectorType) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(collectionName)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .groupByFieldName(CommonData.fieldInt8)
+                .groupSize(CommonData.groupSize)
+                .data(data)
+                .strictGroupSize(true)
+                .topK(10)
+                .build());
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertEquals(search.getSearchResults().get(0).size(), 10 * CommonData.groupSize);
+        }
+    }
+
+    @Test(description = "search enable recall calculation", groups = {"Cloud","L1"}, dataProvider = "VectorTypeList")
+    public void searchEnableRecallCalculation(String collectionName, DataType vectorType) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
+        Map<String, Object> params = new HashMap<>();
+        params.put("level", 1);
+        params.put("enable_recall_calculation", true);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(collectionName)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .data(data)
+                .topK(10)
+                .searchParams(params)
+                .build());
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        // 云上实例才有recall
+       /* if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertTrue(search.getRecalls().get(0) > 0);
+        }*/
+    }
+
+    @Test(description = "search with expression template", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchWithExpressionTemplate(String collectionName, DataType vectorType) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
+        Map<String, Map<String, Object>> expressionTemplateValues = new HashMap<>();
+        List<Object> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        Map<String, Object> params = new HashMap<>();
+        params.put("list", list);
+        params.put("list2", Lists.newArrayList(11,12,13,14,15,16,17,18,19,20));
+        expressionTemplateValues.put(CommonData.fieldInt64 + " in {list}", params);
+        expressionTemplateValues.put(CommonData.fieldInt64 + " in {list2}", params);
+        expressionTemplateValues.forEach((key, value) -> {
+            SearchResp search = milvusClientV2.search(SearchReq.builder()
+                    .collectionName(collectionName)
+                    .outputFields(Lists.newArrayList("*"))
+                    .consistencyLevel(ConsistencyLevel.STRONG)
+                    .filter(key)
+                    .filterTemplateValues(value)
+                    .data(data)
+                    .topK(100)
+                    .build());
+            Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+            if (vectorType != DataType.SparseFloatVector) {
+                Assert.assertEquals(search.getSearchResults().get(0).size(), 10);
+            }
+        });
+    }
+
+    @Test(description = "search use hints", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchWithHints(String collectionName, DataType vectorType){
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
+        Map<String,Object> params=new HashMap<>();
+        params.put("hints","iterative_filter");
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(collectionName)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .data(data)
+                .searchParams(params)
+                .topK(10)
+                .build());
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        if (vectorType != DataType.SparseFloatVector) {
+            Assert.assertEquals(search.getSearchResults().get(0).size(), 10 );
+        }
+    }
 }

tests/milvustestv2/src/test/java/com/zilliz/milvustestv2/vectorOperation/UpsertTest.java

@@ -106,7 +106,7 @@ public class UpsertTest extends BaseTest {
 
     @Test(description = "upsert collection", groups = {"Smoke"})
     public void simpleUpsert() {
-        String collection = CommonFunction.createSimpleCollection(128, null);
+        String collection = CommonFunction.createSimpleCollection(128, null,false);
         List<JsonObject> jsonObjects = CommonFunction.generateSimpleData(CommonData.numberEntities, CommonData.dim);
         milvusClientV2.insert(InsertReq.builder().collectionName(collection).data(jsonObjects).build());
         List<JsonObject> jsonObjectsNew = CommonFunction.generateSimpleData(10, CommonData.dim);