Modfiy testcases for java v1&v2 (#967)

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

tests/milvustest/allure-results/environment.properties

@@ -1,3 +1,3 @@
-milvus.url=10.100.31.102
-milvus.version=2.1.0
-milvus-jdk-java.version=2.1.0
+milvus.url=10.102.9.177
+milvus.version=2.2.2
+milvus-jdk-java.version=2.2.0

tests/milvustest/pom.xml

@@ -84,7 +84,7 @@
         <dependency>
             <groupId>io.milvus</groupId>
             <artifactId>milvus-sdk-java</artifactId>
-            <version>2.2.12</version>
+            <version>2.4.0</version>
         </dependency>
         <dependency>
             <groupId>com.google.protobuf</groupId>

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

@@ -1,3 +1,4 @@
+/*
 package com.zilliz.milvustest.common;
 
 import com.zilliz.milvustest.MilvustestApplication;
@@ -30,7 +31,7 @@ import java.util.List;
 @WebAppConfiguration
 public class BaseCloudTest extends AbstractTestNGSpringContextTests {
 //  public static final Logger logger= LoggerFactory.getLogger(BaseCloudTest.class);
-  public static final MilvusServiceClient milvusCloudClient =
+  public   MilvusServiceClient milvusCloudClient =
           new MilvusServiceClient(
                   ConnectParam.newBuilder()
                           .withHost(
@@ -135,3 +136,4 @@ public class BaseCloudTest extends AbstractTestNGSpringContextTests {
         });
   }
 }
+*/

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

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

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

@@ -36,6 +36,7 @@ public class CommonData {
   public static String defaultRoleName2 = "roleTest2";
   public static String databaseName1="db1";
   public static String databaseName2="db2";
+  public static String databaseName3="db3";
 
   public static int dim=128;
 }

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

@@ -4,6 +4,7 @@ import com.google.gson.*;
 import com.google.common.collect.Lists;
 import com.zilliz.milvustest.entity.FileBody;
 import com.zilliz.milvustest.entity.MilvusEntity;
+import com.zilliz.milvustest.util.JacksonUtil;
 import com.zilliz.milvustest.util.MathUtil;
 import io.milvus.grpc.DataType;
 import io.milvus.param.*;
@@ -611,7 +612,7 @@ public class CommonFunction {
     List<InsertParam.Field> fields = new ArrayList<>();
     fields.add(new InsertParam.Field("word_count", word_count_array));
     fields.add(new InsertParam.Field(CommonData.defaultVectorField, book_intro_array));
-    // logger.info("generateTestData"+ JacksonUtil.serialize(fields));
+     logger.info("generateTestData"+ JacksonUtil.serialize(fields));
     return fields;
   }
 

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

@@ -243,5 +243,35 @@ public class MathUtil {
   }
 
 
+  // 将 32 位浮点数转换为 BF16 格式
+  private static short floatToBF16_2(float value) {
+    int bits = Float.floatToIntBits(value);
+    int sign = bits >>> 31;
+    int exp = (bits >>> 23) & 0xFF;
+    int mantissa = bits & 0x7FFFFF;
 
+    // 将 32 位浮点数的值转换为 BF16 格式
+    short bf16 = (short) ((sign << 15) | ((exp - 127 + 15) << 7) | (mantissa >>> 16));
+
+    return bf16;
+  }
+
+  public static void main(String[] args) {
+    Random random = new Random();
+    float randomFloat;
+    for (int i = 0; i < 10000; i++) {
+      do {
+        randomFloat = random.nextFloat();
+      } while (Float.isInfinite(randomFloat));
+
+      // 将 32 位浮点数转换为 BF16 格式
+      short bf16 = floatToBF16(randomFloat);
+
+      System.out.println("随机生成的 BF16 数为: " + bf16);
+    }
+    // 生成随机数并排除无穷大和 NaN
+
+
+
+  }
 }

tests/milvustest/src/test/java/com/zilliz/milvustest/bulkimport/BulkImportTest.java

@@ -1,3 +1,4 @@
+/*
 package com.zilliz.milvustest.bulkimport;
 
 import com.google.gson.*;
@@ -31,10 +32,12 @@ import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
+*/
 /**
  * @Author xuan.qi
  * @Date 2024/3/21 17:34
- */
+ *//*
+
 public class BulkImportTest extends BaseCloudTest {
     String ALL_TYPES_COLLECTION_NAME = "all_types_for_bulkwriter";
 
@@ -206,7 +209,7 @@ public class BulkImportTest extends BaseCloudTest {
         return new RemoteBulkWriter(bulkWriterParam);
     }
 
-    private static StorageConnectParam buildStorageConnectParam() {
+    private  StorageConnectParam buildStorageConnectParam() {
         StorageConnectParam connectParam;
         if (Objects.equals(PropertyFilesUtil.getRunValue("storageType"), "azure")) {
             String connectionStr = "DefaultEndpointsProtocol=https;AccountName=" + PropertyFilesUtil.getRunValue("azureAccountName") +
@@ -296,7 +299,7 @@ public class BulkImportTest extends BaseCloudTest {
         System.out.printf("Collection %s created%n", collectionName);
     }
 
-    @Test(description = "bulk remote import test")
+    @Test(description = "bulk remote import test",enabled = false)
     public void bulkRemoteImportTest() throws Exception {
         String cloudEndpoint = PropertyFilesUtil.getRunValue("cloudEndpoint");
         String apiKey = PropertyFilesUtil.getRunValue("apikey");
@@ -347,4 +350,4 @@ public class BulkImportTest extends BaseCloudTest {
     }
 
 
-}
+}*/

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

@@ -1,108 +0,0 @@
-package com.zilliz.milvustest.businessflow;
-
-import com.zilliz.milvustest.common.CommonData;
-import com.zilliz.milvustest.util.PropertyFilesUtil;
-import io.milvus.client.MilvusServiceClient;
-import io.milvus.common.clientenum.ConsistencyLevelEnum;
-import io.milvus.grpc.SearchResults;
-import io.milvus.param.ConnectParam;
-import io.milvus.param.MetricType;
-import io.milvus.param.R;
-import io.milvus.param.collection.LoadCollectionParam;
-import io.milvus.param.dml.SearchParam;
-import org.testng.annotations.Test;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.*;
-
-/**
- * @Author yongpeng.li
- * @Date 2022/9/27 10:55
- */
-public class PerformanceTest2 {
-
-    static  MilvusServiceClient milvusClient =
-            new MilvusServiceClient(
-                    ConnectParam.newBuilder()
-                            .withHost(
-                                    System.getProperty("milvusHost") == null
-                                            ? PropertyFilesUtil.getRunValue("milvusHost")
-                                            : System.getProperty("milvusHost"))
-                            .withPort(
-                                    Integer.parseInt(
-                                            System.getProperty("milvusPort") == null
-                                                    ? PropertyFilesUtil.getRunValue("milvusPort")
-                                                    : System.getProperty("milvusPort")))
-                            .withAuthorization("root","Z5:&RCg%d(MQ[gLnPT:tV!nJaJAdp@:$")
-                            .withSecure(true)
-                            .build());
-
-
-    @Test
-    public void concurrentSearch2() {
-
-        milvusClient.loadCollection(LoadCollectionParam.newBuilder().withCollectionName("book").build());
-        int dim = 128;
-        Random ran = new Random();
-        final Integer SEARCH_K = 2; // TopK
-        final String SEARCH_PARAM = "{\"nprobe\":1}"; // Params
-        List<String> search_output_fields = Arrays.asList("book_id", "word_count");
-
-        // concurrent search
-        ExecutorService executorService = Executors.newFixedThreadPool(50);
-        ArrayList<Future> list = new ArrayList<>();
-        for (int j = 0; j < 50; j++) {
-            Callable callable =
-                    () -> {
-                        List<Object> results = new ArrayList<>();
-                        for (int i = 0; i < 10000; i++) {
-                            List<Float> floatList = new ArrayList<>();
-                            for (int k = 0; k < dim; ++k) {
-                                floatList.add(ran.nextFloat());
-                            }
-                            List<List<Float>> search_vectors = Arrays.asList(floatList);
-                            SearchParam searchParam =
-                                    SearchParam.newBuilder()
-                                            .withCollectionName("book")
-                                            .withMetricType(MetricType.L2)
-                                            .withOutFields(search_output_fields)
-                                            .withTopK(SEARCH_K)
-                                            .withVectors(search_vectors)
-                                            .withVectorFieldName("book_intro")
-                                            .withRoundDecimal(4)
-                                            .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
-                                            .withParams(SEARCH_PARAM)
-                                            .build();
-                            R<SearchResults> search = milvusClient.search(searchParam);
-                            results.add(search.getStatus());
-                        }
-                        return results;
-                    };
-            Future future = executorService.submit(callable);
-            list.add(future);
-        }
-        executorService.shutdown();
-
-        int sucNUm=0;
-        int failNum=0;
-        // 遍历future
-        for (Future future : list) {
-            try {
-                if(future.get().toString().equals("0")){
-                    sucNUm+=1;
-                }else{
-                    failNum+=1;
-                }
-                System.out.println(future);
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            } catch (ExecutionException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-}
-

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

@@ -27,450 +27,421 @@ import java.util.concurrent.*;
 @Epic("Collection")
 @Feature("CreateCollection")
 public class CreateCollectionTest extends BaseTest {
-  public String commonCollection;
-  public String binaryVectorCollection;
+    public String commonCollection;
+    public String binaryVectorCollection;
 
-  public String stringPKCollection;
-  public String maxFieldCollection;
+    public String stringPKCollection;
+    public String maxFieldCollection;
 
-  public String arrayFieldCollection;
+    public String arrayFieldCollection;
 
-  public String float16FieldCollection;
-  public String bf16FieldCollection;
+    public String float16FieldCollection;
+    public String bf16FieldCollection;
 
-  public String sparseVectorCollection;
+    public String sparseVectorCollection;
 
-  public String multiVectorCollection;
+    public String multiVectorCollection;
 
-  @DataProvider(name = "collectionByDataProvider")
-  public Object[][] provideCollectionName() {
-    return new String[][] {{"collection_" + MathUtil.getRandomString(10)}};
-  }
+    @DataProvider(name = "collectionByDataProvider")
+    public Object[][] provideCollectionName() {
+        return new String[][]{{"collection_" + MathUtil.getRandomString(10)}};
+    }
 
-  @AfterClass(description = "delete test datas after CreateCollectionTest", alwaysRun = true)
-  public void deleteTestData() {
-    if (commonCollection != null) {
-      milvusClient.dropCollection(
-          DropCollectionParam.newBuilder().withCollectionName(commonCollection).build());
+    @AfterClass(description = "delete test datas after CreateCollectionTest", alwaysRun = true)
+    public void deleteTestData() {
+        if (commonCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(commonCollection).build());
+        }
+        if (binaryVectorCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(binaryVectorCollection).build());
+        }
+        if (stringPKCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+        }
+        if (maxFieldCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(maxFieldCollection).build());
+        }
+        if (arrayFieldCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(arrayFieldCollection).build());
+        }
+        if (float16FieldCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(float16FieldCollection).build());
+        }
+        if (bf16FieldCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(bf16FieldCollection).build());
+        }
+        if (sparseVectorCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(sparseVectorCollection).build());
+        }
+        if (multiVectorCollection != null) {
+            milvusClient.dropCollection(
+                    DropCollectionParam.newBuilder().withCollectionName(multiVectorCollection).build());
+        }
     }
-    if (binaryVectorCollection != null) {
-      milvusClient.dropCollection(
-          DropCollectionParam.newBuilder().withCollectionName(binaryVectorCollection).build());
+
+    @DataProvider(name = "dataTypeProvider")
+    public Object[][] provideDataType() {
+        Object[][] pk = new Object[][]{{DataType.Int64}, {DataType.VarChar}};
+        Object[][] filedType =
+                new Object[][]{
+                        {DataType.Double},
+                        {DataType.Float},
+                        {DataType.Int64},
+                        {DataType.Int8},
+                        {DataType.Int16},
+                        {DataType.Int32},
+                        {DataType.VarChar}
+                };
+        Object[][] vectorType = new Object[][]{{DataType.FloatVector}, {DataType.BinaryVector}};
+        Object[][] dataType = new Object[pk.length * filedType.length * vectorType.length][3];
+        int a = 0;
+        for (int i = 0; i < pk.length; i++) {
+            for (int j = 0; j < filedType.length; j++) {
+                for (int k = 0; k < vectorType.length; k++) {
+                    dataType[a][0] = pk[i][0];
+                    dataType[a][1] = filedType[j][0];
+                    dataType[a][2] = vectorType[k][0];
+                    a++;
+                }
+            }
+        }
+        return dataType;
     }
-    if (stringPKCollection != null) {
-      milvusClient.dropCollection(
-          DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "Create collection success",
+            dataProvider = "collectionByDataProvider",
+            groups = {"Smoke"})
+    public void createCollectionSuccess(String collectionName) {
+        commonCollection = collectionName;
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .withDescription("Test " + collectionName + " search")
+                        .withShardsNum(2)
+                        .withSchema(
+                                CollectionSchemaParam.newBuilder()
+                                        .addFieldType(fieldType1)
+                                        .addFieldType(fieldType2)
+                                        .addFieldType(fieldType3)
+                                        .build())
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
     }
-    if (maxFieldCollection != null) {
-      milvusClient.dropCollection(
-          DropCollectionParam.newBuilder().withCollectionName(maxFieldCollection).build());
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(
+            description = "Repeat create collection",
+            dependsOnMethods = {"createCollectionSuccess"})
+    public void createCollectionRepeat() {
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(2)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(commonCollection)
+                        .withDescription("Test" + commonCollection + "search")
+                        .withShardsNum(2)
+                        .withSchema(
+                                CollectionSchemaParam.newBuilder()
+                                        .addFieldType(fieldType1)
+                                        .addFieldType(fieldType2)
+                                        .addFieldType(fieldType3)
+                                        .build())
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "1");
+        Assert.assertEquals(
+                collection.getException().getMessage(),
+                "CreateCollection failed: meta table add collection failed,error = collection "
+                        + commonCollection
+                        + " exist");
     }
-    if (arrayFieldCollection != null) {
-      milvusClient.dropCollection(
-              DropCollectionParam.newBuilder().withCollectionName(arrayFieldCollection).build());
+
+    @Severity(SeverityLevel.MINOR)
+    @Test(description = "Create collection without params", expectedExceptions = ParamException.class)
+    public void createCollectionWithoutCollectionName() {
+        R<RpcStatus> rpcStatusR =
+                milvusClient.createCollection(CreateCollectionParam.newBuilder().build());
+        System.out.println(rpcStatusR);
     }
-    if (float16FieldCollection != null) {
-      milvusClient.dropCollection(
-              DropCollectionParam.newBuilder().withCollectionName(float16FieldCollection).build());
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "Create binary vector collection", dataProvider = "collectionByDataProvider")
+    public void createBinaryVectorCollection(String collectionName) {
+        binaryVectorCollection = collectionName;
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType fieldType33 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.BinaryVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .withDescription("Test " + collectionName + " search")
+                        .withShardsNum(2)
+                        .withSchema(CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType2).addFieldType(fieldType33).build())
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
     }
-    if (bf16FieldCollection != null) {
-      milvusClient.dropCollection(
-              DropCollectionParam.newBuilder().withCollectionName(bf16FieldCollection).build());
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "Create String collection", dataProvider = "collectionByDataProvider")
+    public void createStringPKCollection(String collectionName) {
+        stringPKCollection = collectionName;
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_name")
+                        .withDataType(DataType.VarChar)
+                        .withMaxLength(20)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder()
+                        .withName("book_content")
+                        .withDataType(DataType.VarChar)
+                        .withMaxLength(10)
+                        .build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .withDescription("Test " + collectionName + " search")
+                        .withShardsNum(2)
+                        .withSchema(
+                                CollectionSchemaParam.newBuilder()
+                                        .addFieldType(fieldType1)
+                                        .addFieldType(fieldType2)
+                                        .addFieldType(fieldType3)
+                                        .build())
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
     }
-    if (sparseVectorCollection != null) {
-      milvusClient.dropCollection(
-              DropCollectionParam.newBuilder().withCollectionName(sparseVectorCollection).build());
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(
+            description = "Create String collection without max length",
+            dataProvider = "collectionByDataProvider",
+            expectedExceptions = ParamException.class)
+    public void createStringPKCollectionWithoutMaxLength(String collectionName) {
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_name")
+                        .withDataType(DataType.VarChar)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder().withName("book_content").withDataType(DataType.VarChar).build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .withDescription("Test " + collectionName + " search")
+                        .withShardsNum(2)
+                        .withSchema(
+                                CollectionSchemaParam.newBuilder()
+                                        .addFieldType(fieldType1)
+                                        .addFieldType(fieldType2)
+                                        .addFieldType(fieldType3)
+                                        .build())
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "1");
+        Assert.assertEquals(
+                collection.getData().getMsg(), "Varchar field max length must be specified");
     }
-    if (multiVectorCollection != null) {
-      milvusClient.dropCollection(
-              DropCollectionParam.newBuilder().withCollectionName(multiVectorCollection).build());
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(
+            description = "Float vector collection using each data type",
+            dataProvider = "dataTypeProvider")
+    public void createCollectionWithEachDataType(
+            DataType pk, DataType fieldType, DataType vectorType) {
+        String collectionName = "coll" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(pk)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .withMaxLength(10)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder()
+                        .withName("word_count")
+                        .withDataType(fieldType)
+                        .withMaxLength(10)
+                        .build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(vectorType)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .withDescription("Test " + collectionName + " search")
+                        .withShardsNum(2)
+                        .withSchema(
+                                CollectionSchemaParam.newBuilder()
+                                        .addFieldType(fieldType1)
+                                        .addFieldType(fieldType2)
+                                        .addFieldType(fieldType3)
+                                        .build())
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
+        milvusClient.dropCollection(
+                DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
     }
-  }
-
-  @DataProvider(name = "dataTypeProvider")
-  public Object[][] provideDataType() {
-    Object[][] pk = new Object[][] {{DataType.Int64}, {DataType.VarChar}};
-    Object[][] filedType =
-        new Object[][] {
-          {DataType.Double},
-          {DataType.Float},
-          {DataType.Int64},
-          {DataType.Int8},
-          {DataType.Int16},
-          {DataType.Int32},
-          {DataType.VarChar}
-        };
-    Object[][] vectorType = new Object[][] {{DataType.FloatVector}, {DataType.BinaryVector}};
-    Object[][] dataType = new Object[pk.length * filedType.length * vectorType.length][3];
-    int a = 0;
-    for (int i = 0; i < pk.length; i++) {
-      for (int j = 0; j < filedType.length; j++) {
-        for (int k = 0; k < vectorType.length; k++) {
-          dataType[a][0] = pk[i][0];
-          dataType[a][1] = filedType[j][0];
-          dataType[a][2] = vectorType[k][0];
-          a++;
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "Create collection with max fields")
+    public void createCollectionWithMaxFields() {
+        maxFieldCollection = "coll_" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam.Builder builder = CreateCollectionParam.newBuilder();
+        builder
+                .withCollectionName(maxFieldCollection)
+                .withDescription("Test " + maxFieldCollection + " search")
+                .withShardsNum(2)
+                .withSchema(
+                        CollectionSchemaParam.newBuilder()
+                                .addFieldType(fieldType1)
+                                .addFieldType(fieldType3).build());
+
+        for (int i = 0; i < 254; i++) {
+            FieldType field =
+                    FieldType.newBuilder().withName("field_" + i).withDataType(DataType.Int64).build();
+            builder.addFieldType(field);
         }
-      }
-    }
-    return dataType;
-  }
-
-  @Severity(SeverityLevel.BLOCKER)
-  @Test(
-      description = "Create collection success",
-      dataProvider = "collectionByDataProvider",
-      groups = {"Smoke"})
-  public void createCollectionSuccess(String collectionName) {
-    commonCollection = collectionName;
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_id")
-            .withDataType(DataType.Int64)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-    FieldType fieldType2 =
-        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.FloatVector)
-            .withDimension(128)
-            .build();
-    CreateCollectionParam createCollectionReq =
-        CreateCollectionParam.newBuilder()
-            .withCollectionName(collectionName)
-            .withDescription("Test " + collectionName + " search")
-            .withShardsNum(2)
-            .addFieldType(fieldType1)
-            .addFieldType(fieldType2)
-            .addFieldType(fieldType3)
-            .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Severity(SeverityLevel.NORMAL)
-  @Test(
-      description = "Repeat create collection",
-      dependsOnMethods = {"createCollectionSuccess"})
-  public void createCollectionRepeat() {
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_id")
-            .withDataType(DataType.Int64)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-    FieldType fieldType2 =
-        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.FloatVector)
-            .withDimension(2)
-            .build();
-    CreateCollectionParam createCollectionReq =
-        CreateCollectionParam.newBuilder()
-            .withCollectionName(commonCollection)
-            .withDescription("Test" + commonCollection + "search")
-            .withShardsNum(2)
-            .addFieldType(fieldType1)
-            .addFieldType(fieldType2)
-            .addFieldType(fieldType3)
-            .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "1");
-    Assert.assertEquals(
-        collection.getException().getMessage(),
-        "CreateCollection failed: meta table add collection failed,error = collection "
-            + commonCollection
-            + " exist");
-  }
-
-  @Severity(SeverityLevel.MINOR)
-  @Test(description = "Create collection without params", expectedExceptions = ParamException.class)
-  public void createCollectionWithoutCollectionName() {
-    R<RpcStatus> rpcStatusR =
-        milvusClient.createCollection(CreateCollectionParam.newBuilder().build());
-    System.out.println(rpcStatusR);
-  }
-
-  @Severity(SeverityLevel.BLOCKER)
-  @Test(description = "Create binary vector collection", dataProvider = "collectionByDataProvider")
-  public void createBinaryVectorCollection(String collectionName) {
-    binaryVectorCollection = collectionName;
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_id")
-            .withDataType(DataType.Int64)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-    FieldType fieldType2 =
-        FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.BinaryVector)
-            .withDimension(128)
-            .build();
-    CreateCollectionParam createCollectionReq =
-        CreateCollectionParam.newBuilder()
-            .withCollectionName(collectionName)
-            .withDescription("Test " + collectionName + " search")
-            .withShardsNum(2)
-            .addFieldType(fieldType1)
-            .addFieldType(fieldType2)
-            .addFieldType(fieldType3)
-            .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Severity(SeverityLevel.BLOCKER)
-  @Test(description = "Create String collection", dataProvider = "collectionByDataProvider")
-  public void createStringPKCollection(String collectionName) {
-    stringPKCollection = collectionName;
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_name")
-            .withDataType(DataType.VarChar)
-            .withMaxLength(20)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-    FieldType fieldType2 =
-        FieldType.newBuilder()
-            .withName("book_content")
-            .withDataType(DataType.VarChar)
-            .withMaxLength(10)
-            .build();
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.FloatVector)
-            .withDimension(128)
-            .build();
-    CreateCollectionParam createCollectionReq =
-        CreateCollectionParam.newBuilder()
-            .withCollectionName(collectionName)
-            .withDescription("Test " + collectionName + " search")
-            .withShardsNum(2)
-            .addFieldType(fieldType1)
-            .addFieldType(fieldType2)
-            .addFieldType(fieldType3)
-            .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Severity(SeverityLevel.NORMAL)
-  @Test(
-      description = "Create String collection without max length",
-      dataProvider = "collectionByDataProvider",
-      expectedExceptions = ParamException.class)
-  public void createStringPKCollectionWithoutMaxLength(String collectionName) {
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_name")
-            .withDataType(DataType.VarChar)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-    FieldType fieldType2 =
-        FieldType.newBuilder().withName("book_content").withDataType(DataType.VarChar).build();
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.FloatVector)
-            .withDimension(128)
-            .build();
-    CreateCollectionParam createCollectionReq =
-        CreateCollectionParam.newBuilder()
-            .withCollectionName(collectionName)
-            .withDescription("Test " + collectionName + " search")
-            .withShardsNum(2)
-            .addFieldType(fieldType1)
-            .addFieldType(fieldType2)
-            .addFieldType(fieldType3)
-            .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "1");
-    Assert.assertEquals(
-        collection.getData().getMsg(), "Varchar field max length must be specified");
-  }
-
-  @Severity(SeverityLevel.BLOCKER)
-  @Test(
-      description = "Float vector collection using each data type",
-      dataProvider = "dataTypeProvider")
-  public void createCollectionWithEachDataType(
-      DataType pk, DataType fieldType, DataType vectorType) {
-    String collectionName = "coll" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_id")
-            .withDataType(pk)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .withMaxLength(10)
-            .build();
-    FieldType fieldType2 =
-        FieldType.newBuilder()
-            .withName("word_count")
-            .withDataType(fieldType)
-            .withMaxLength(10)
-            .build();
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(vectorType)
-            .withDimension(128)
-            .build();
-    CreateCollectionParam createCollectionReq =
-        CreateCollectionParam.newBuilder()
-            .withCollectionName(collectionName)
-            .withDescription("Test " + collectionName + " search")
-            .withShardsNum(2)
-            .addFieldType(fieldType1)
-            .addFieldType(fieldType2)
-            .addFieldType(fieldType3)
-            .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-    milvusClient.dropCollection(
-        DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
-  }
-
-  @Severity(SeverityLevel.NORMAL)
-  @Test(description = "Create collection with max fields")
-  public void createCollectionWithMaxFields() {
-    maxFieldCollection = "coll_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_id")
-            .withDataType(DataType.Int64)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.FloatVector)
-            .withDimension(128)
-            .build();
-    CreateCollectionParam.Builder builder = CreateCollectionParam.newBuilder();
-    builder
-        .withCollectionName(maxFieldCollection)
-        .withDescription("Test " + maxFieldCollection + " search")
-        .withShardsNum(2)
-        .addFieldType(fieldType1)
-        .addFieldType(fieldType3);
-
-    for (int i = 0; i < 254; i++) {
-      FieldType field =
-          FieldType.newBuilder().withName("field_" + i).withDataType(DataType.Int64).build();
-      builder.addFieldType(field);
+        R<RpcStatus> collection = milvusClient.createCollection(builder.build());
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
     }
-    R<RpcStatus> collection = milvusClient.createCollection(builder.build());
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Severity(SeverityLevel.NORMAL)
-  @Test(description = "Create collection with max fields")
-  public void createCollectionWith257Fields() {
-    maxFieldCollection = "coll_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_id")
-            .withDataType(DataType.Int64)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.FloatVector)
-            .withDimension(128)
-            .build();
-    CreateCollectionParam.Builder builder = CreateCollectionParam.newBuilder();
-    builder
-        .withCollectionName(maxFieldCollection)
-        .withDescription("Test " + maxFieldCollection + " search")
-        .withShardsNum(2)
-        .addFieldType(fieldType1)
-        .addFieldType(fieldType3);
-
-    for (int i = 0; i < 255; i++) {
-      FieldType field =
-          FieldType.newBuilder().withName("field_" + i).withDataType(DataType.Int64).build();
-      builder.addFieldType(field);
-    }
-    R<RpcStatus> collection = milvusClient.createCollection(builder.build());
-    Assert.assertEquals(collection.getStatus().intValue(), 1);
-    Assert.assertTrue(
-        collection
-            .getException()
-            .getMessage()
-            .contains("maximum field's number should be limited to 256"));
-  }
-
-  @Severity(SeverityLevel.NORMAL)
-  @Test(description = "Create collection with multiple PK")
-  public void createCollectionWithMultiPK() {
-    String collection = "coll_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-        FieldType.newBuilder()
-            .withName("book_id")
-            .withDataType(DataType.Int64)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-    FieldType fieldType2 =
-        FieldType.newBuilder()
-            .withName("word_count")
-            .withDataType(DataType.Int64)
-            .withPrimaryKey(true)
-            .withAutoID(false)
-            .build();
-    FieldType fieldType3 =
-        FieldType.newBuilder()
-            .withName("book_intro")
-            .withDataType(DataType.FloatVector)
-            .withDimension(128)
-            .build();
-    R<RpcStatus> collectionR =
-        milvusClient.createCollection(
-            CreateCollectionParam.newBuilder()
-                .withCollectionName(collection)
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "Create collection with max fields")
+    public void createCollectionWith257Fields() {
+        maxFieldCollection = "coll_" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("book_intro")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        CreateCollectionParam.Builder builder = CreateCollectionParam.newBuilder();
+        builder
+                .withCollectionName(maxFieldCollection)
+                .withDescription("Test " + maxFieldCollection + " search")
                 .withShardsNum(2)
-                .addFieldType(fieldType1)
-                .addFieldType(fieldType2)
-                .addFieldType(fieldType3)
-                .build());
-    Assert.assertEquals(collectionR.getStatus().intValue(), 1);
-    Assert.assertTrue(collectionR.getException().getMessage().contains("there are more than one primary key"));
-  }
-
-  @Severity(SeverityLevel.NORMAL)
-  @Test(description = "Create collection with multiple thread")
-  public void createCollectionWithMultiThread() {
-    ExecutorService executorService= Executors.newFixedThreadPool(5);
-    List<Future> futures=new ArrayList<>();
-    for (int i = 0; i < 5; i++) {
-      int finalI = i;
-      Callable callable= () -> {
-        String collection="Col_"+ finalI +MathUtil.getRandomString(10);
-        Integer resultCode;
+                .withSchema(CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType3).build());
+
+        for (int i = 0; i < 255; i++) {
+            FieldType field =
+                    FieldType.newBuilder().withName("field_" + i).withDataType(DataType.Int64).build();
+            builder.addFieldType(field);
+        }
+        R<RpcStatus> collection = milvusClient.createCollection(builder.build());
+        Assert.assertEquals(collection.getStatus().intValue(), 1);
+        Assert.assertTrue(
+                collection
+                        .getException()
+                        .getMessage()
+                        .contains("maximum field's number should be limited to 256"));
+    }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "Create collection with multiple PK")
+    public void createCollectionWithMultiPK() {
+        String collection = "coll_" + MathUtil.getRandomString(10);
         FieldType fieldType1 =
                 FieldType.newBuilder()
                         .withName("book_id")
@@ -481,7 +452,10 @@ public class CreateCollectionTest extends BaseTest {
         FieldType fieldType2 =
                 FieldType.newBuilder()
                         .withName("word_count")
-                        .withDataType(DataType.Int64).build();
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
         FieldType fieldType3 =
                 FieldType.newBuilder()
                         .withName("book_intro")
@@ -493,216 +467,265 @@ public class CreateCollectionTest extends BaseTest {
                         CreateCollectionParam.newBuilder()
                                 .withCollectionName(collection)
                                 .withShardsNum(2)
-                                .addFieldType(fieldType1)
-                                .addFieldType(fieldType2)
-                                .addFieldType(fieldType3)
+                                .withSchema(
+                                        CollectionSchemaParam.newBuilder()
+                                               .addFieldType(fieldType1)
+                                               .addFieldType(fieldType2)
+                                               .addFieldType(fieldType3)
+                                               .build())
                                 .build());
-        resultCode=collectionR.getStatus();
-        milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(collection).build());
-        return resultCode;
-      };
-      Future submit = executorService.submit(callable);
-      futures.add(submit);
+        Assert.assertEquals(collectionR.getStatus().intValue(), 1);
+        Assert.assertTrue(collectionR.getException().getMessage().contains("there are more than one primary key"));
+    }
+
+    @Severity(SeverityLevel.NORMAL)
+    @Test(description = "Create collection with multiple thread")
+    public void createCollectionWithMultiThread() {
+        ExecutorService executorService = Executors.newFixedThreadPool(5);
+        List<Future> futures = new ArrayList<>();
+        for (int i = 0; i < 5; i++) {
+            int finalI = i;
+            Callable callable = () -> {
+                String collection = "Col_" + finalI + MathUtil.getRandomString(10);
+                Integer resultCode;
+                FieldType fieldType1 =
+                        FieldType.newBuilder()
+                                .withName("book_id")
+                                .withDataType(DataType.Int64)
+                                .withPrimaryKey(true)
+                                .withAutoID(false)
+                                .build();
+                FieldType fieldType2 =
+                        FieldType.newBuilder()
+                                .withName("word_count")
+                                .withDataType(DataType.Int64).build();
+                FieldType fieldType3 =
+                        FieldType.newBuilder()
+                                .withName("book_intro")
+                                .withDataType(DataType.FloatVector)
+                                .withDimension(128)
+                                .build();
+                R<RpcStatus> collectionR =
+                        milvusClient.createCollection(
+                                CreateCollectionParam.newBuilder()
+                                        .withCollectionName(collection)
+                                        .withShardsNum(2)
+                                        .withSchema(
+                                                CollectionSchemaParam.newBuilder()
+                                                       .addFieldType(fieldType1)
+                                                       .addFieldType(fieldType2)
+                                                       .addFieldType(fieldType3)
+                                                       .build())
+                                        .build());
+                resultCode = collectionR.getStatus();
+                milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(collection).build());
+                return resultCode;
+            };
+            Future submit = executorService.submit(callable);
+            futures.add(submit);
+        }
+        futures.forEach(x -> {
+            try {
+                Assert.assertEquals(x.get().toString(), "0");
+            } catch (InterruptedException | ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    @Severity(SeverityLevel.BLOCKER)
+    @Test(description = "Create collection with array fields")
+    public void createCollectionWithArrayField() {
+        arrayFieldCollection = "Collection_" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("int64_field")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder()
+                        .withName("float_vector")
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(128)
+                        .build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName("str_array_field")
+                        .withDataType(DataType.Array)
+                        .withElementType(DataType.VarChar)
+                        .withMaxLength(256)
+                        .withMaxCapacity(300)
+                        .build();
+        FieldType fieldType4 =
+                FieldType.newBuilder()
+                        .withName("int_array_field")
+                        .withDataType(DataType.Array)
+                        .withElementType(DataType.Int64)
+                        .withMaxLength(256)
+                        .withMaxCapacity(300)
+                        .build();
+        FieldType fieldType5 =
+                FieldType.newBuilder()
+                        .withName("float_array_field")
+                        .withDataType(DataType.Array)
+                        .withElementType(DataType.Float)
+                        .withMaxLength(256)
+                        .withMaxCapacity(300)
+                        .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(arrayFieldCollection)
+                        .withDescription("Test" + arrayFieldCollection + "search")
+                        .withShardsNum(2)
+                        .withSchema(
+                                CollectionSchemaParam.newBuilder()
+                                        .addFieldType(fieldType1)
+                                        .addFieldType(fieldType2)
+                                        .addFieldType(fieldType3)
+                                        .addFieldType(fieldType4)
+                                        .addFieldType(fieldType5)
+                                        .build())
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
+    }
+
+    @Test(description = "Create collection with float16 field", groups = {"Smoke"})
+    public void createCollectionWithFloat16Vector() {
+        float16FieldCollection = "Collection_" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("int64_field")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder()
+                        .withName("float_vector")
+                        .withDataType(DataType.Float16Vector)
+                        .withDimension(128)
+                        .build();
+        CollectionSchemaParam schemaParam = CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType2).build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(float16FieldCollection)
+                        .withDescription("Test" + float16FieldCollection + "search")
+                        .withShardsNum(2)
+                        .withSchema(schemaParam)
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
+    }
+
+    @Test(description = "Create collection with bf16 field", groups = {"Smoke"})
+    public void createCollectionWithBf16Vector() {
+        bf16FieldCollection = "Collection_" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("int64_field")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder()
+                        .withName("float_vector")
+                        .withDataType(DataType.BFloat16Vector)
+                        .withDimension(128)
+                        .build();
+        CollectionSchemaParam schemaParam = CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType2).build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(bf16FieldCollection)
+                        .withDescription("Test" + bf16FieldCollection + "search")
+                        .withShardsNum(2)
+                        .withSchema(schemaParam)
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
+    }
+
+    @Test(description = "Create collection with sparse vector field", groups = {"Smoke"})
+    public void createCollectionWithSparseVector() {
+        sparseVectorCollection = "Collection_" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("int64_field")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder()
+                        .withName("float_vector")
+                        .withDataType(DataType.SparseFloatVector)
+                        .build();
+        CollectionSchemaParam schemaParam = CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType2).build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(sparseVectorCollection)
+                        .withDescription("Test" + sparseVectorCollection + "search")
+                        .withShardsNum(2)
+                        .withSchema(schemaParam)
+                        .build();
+        R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
+    }
+
+    @Test(description = "Create collection with multi vector ", groups = {"Smoke"})
+    public void createCollectionWithMultiVector() {
+        multiVectorCollection = "Collection_" + MathUtil.getRandomString(10);
+        FieldType fieldType1 =
+                FieldType.newBuilder()
+                        .withName("book_id")
+                        .withDataType(DataType.Int64)
+                        .withPrimaryKey(true)
+                        .withAutoID(false)
+                        .build();
+        FieldType fieldType2 =
+                FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
+        FieldType fieldType3 =
+                FieldType.newBuilder()
+                        .withName(CommonData.defaultVectorField)
+                        .withDataType(DataType.FloatVector)
+                        .withDimension(CommonData.dim)
+                        .build();
+        FieldType fieldType4 =
+                FieldType.newBuilder()
+                        .withName(CommonData.defaultBinaryVectorField)
+                        .withDataType(DataType.BinaryVector)
+                        .withDimension(CommonData.dim)
+                        .build();
+        FieldType fieldType5 =
+                FieldType.newBuilder()
+                        .withName(CommonData.defaultSparseVectorField)
+                        .withDataType(DataType.SparseFloatVector)
+                        .build();
+        CollectionSchemaParam collectionSchemaParam = CollectionSchemaParam.newBuilder()
+                .addFieldType(fieldType1)
+                .addFieldType(fieldType2)
+                .addFieldType(fieldType3)
+                .addFieldType(fieldType4)
+                .addFieldType(fieldType5)
+                .build();
+        CreateCollectionParam createCollectionReq =
+                CreateCollectionParam.newBuilder()
+                        .withCollectionName(multiVectorCollection)
+                        .withDescription("Test" + multiVectorCollection + "search")
+                        .withShardsNum(1)
+                        .withSchema(collectionSchemaParam)
+                        .build();
+        R<RpcStatus> collection = BaseTest.milvusClient.createCollection(createCollectionReq);
+        Assert.assertEquals(collection.getStatus().toString(), "0");
+        Assert.assertEquals(collection.getData().getMsg(), "Success");
     }
-    futures.forEach(x->{
-      try {
-        Assert.assertEquals(x.get().toString(),"0");
-      } catch (InterruptedException | ExecutionException e) {
-        throw new RuntimeException(e);
-      }
-    });
-  }
-
-  @Severity(SeverityLevel.BLOCKER)
-  @Test(description = "Create collection with array fields")
-  public void createCollectionWithArrayField(){
-    arrayFieldCollection = "Collection_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-            FieldType.newBuilder()
-                    .withName("int64_field")
-                    .withDataType(DataType.Int64)
-                    .withPrimaryKey(true)
-                    .withAutoID(false)
-                    .build();
-    FieldType fieldType2 =
-            FieldType.newBuilder()
-                    .withName("float_vector")
-                    .withDataType(DataType.FloatVector)
-                    .withDimension(128)
-                    .build();
-    FieldType fieldType3=
-            FieldType.newBuilder()
-                    .withName("str_array_field")
-                    .withDataType(DataType.Array)
-                    .withElementType(DataType.VarChar)
-                    .withMaxLength(256)
-                    .withMaxCapacity(300)
-                    .build();
-    FieldType fieldType4=
-            FieldType.newBuilder()
-                    .withName("int_array_field")
-                    .withDataType(DataType.Array)
-                    .withElementType(DataType.Int64)
-                    .withMaxLength(256)
-                    .withMaxCapacity(300)
-                    .build();
-    FieldType fieldType5=
-            FieldType.newBuilder()
-                    .withName("float_array_field")
-                    .withDataType(DataType.Array)
-                    .withElementType(DataType.Float)
-                    .withMaxLength(256)
-                    .withMaxCapacity(300)
-                    .build();
-    CreateCollectionParam createCollectionReq =
-            CreateCollectionParam.newBuilder()
-                    .withCollectionName(arrayFieldCollection)
-                    .withDescription("Test" + arrayFieldCollection + "search")
-                    .withShardsNum(2)
-                    .addFieldType(fieldType1)
-                    .addFieldType(fieldType2)
-                    .addFieldType(fieldType3)
-                    .addFieldType(fieldType4)
-                    .addFieldType(fieldType5)
-                    .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Test(description = "Create collection with float16 field",groups = {"Smoke"})
-  public void createCollectionWithFloat16Vector(){
-    float16FieldCollection = "Collection_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-            FieldType.newBuilder()
-                    .withName("int64_field")
-                    .withDataType(DataType.Int64)
-                    .withPrimaryKey(true)
-                    .withAutoID(false)
-                    .build();
-    FieldType fieldType2 =
-            FieldType.newBuilder()
-                    .withName("float_vector")
-                    .withDataType(DataType.Float16Vector)
-                    .withDimension(128)
-                    .build();
-    CollectionSchemaParam schemaParam = CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType2).build();
-    CreateCollectionParam createCollectionReq =
-            CreateCollectionParam.newBuilder()
-                    .withCollectionName(float16FieldCollection)
-                    .withDescription("Test" + float16FieldCollection + "search")
-                    .withShardsNum(2)
-                    .withSchema(schemaParam)
-                    .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Test(description = "Create collection with bf16 field",groups = {"Smoke"})
-  public void createCollectionWithBf16Vector(){
-    bf16FieldCollection = "Collection_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-            FieldType.newBuilder()
-                    .withName("int64_field")
-                    .withDataType(DataType.Int64)
-                    .withPrimaryKey(true)
-                    .withAutoID(false)
-                    .build();
-    FieldType fieldType2 =
-            FieldType.newBuilder()
-                    .withName("float_vector")
-                    .withDataType(DataType.BFloat16Vector)
-                    .withDimension(128)
-                    .build();
-    CollectionSchemaParam schemaParam = CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType2).build();
-    CreateCollectionParam createCollectionReq =
-            CreateCollectionParam.newBuilder()
-                    .withCollectionName(bf16FieldCollection)
-                    .withDescription("Test" + bf16FieldCollection + "search")
-                    .withShardsNum(2)
-                    .withSchema(schemaParam)
-                    .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Test(description = "Create collection with sparse vector field",groups = {"Smoke"})
-  public void createCollectionWithSparseVector(){
-    sparseVectorCollection = "Collection_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-            FieldType.newBuilder()
-                    .withName("int64_field")
-                    .withDataType(DataType.Int64)
-                    .withPrimaryKey(true)
-                    .withAutoID(false)
-                    .build();
-    FieldType fieldType2 =
-            FieldType.newBuilder()
-                    .withName("float_vector")
-                    .withDataType(DataType.SparseFloatVector)
-                    .build();
-    CollectionSchemaParam schemaParam = CollectionSchemaParam.newBuilder().addFieldType(fieldType1).addFieldType(fieldType2).build();
-    CreateCollectionParam createCollectionReq =
-            CreateCollectionParam.newBuilder()
-                    .withCollectionName(sparseVectorCollection)
-                    .withDescription("Test" + sparseVectorCollection + "search")
-                    .withShardsNum(2)
-                    .withSchema(schemaParam)
-                    .build();
-    R<RpcStatus> collection = milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
-
-  @Test(description = "Create collection with multi vector ",groups = {"Smoke"})
-  public void createCollectionWithMultiVector(){
-    multiVectorCollection = "Collection_" + MathUtil.getRandomString(10);
-    FieldType fieldType1 =
-            FieldType.newBuilder()
-                    .withName("book_id")
-                    .withDataType(DataType.Int64)
-                    .withPrimaryKey(true)
-                    .withAutoID(false)
-                    .build();
-    FieldType fieldType2 =
-            FieldType.newBuilder().withName("word_count").withDataType(DataType.Int64).build();
-    FieldType fieldType3 =
-            FieldType.newBuilder()
-                    .withName(CommonData.defaultVectorField)
-                    .withDataType(DataType.FloatVector)
-                    .withDimension(CommonData.dim)
-                    .build();
-    FieldType fieldType4 =
-            FieldType.newBuilder()
-                    .withName(CommonData.defaultBinaryVectorField)
-                    .withDataType(DataType.BinaryVector)
-                    .withDimension(CommonData.dim)
-                    .build();
-    FieldType fieldType5 =
-            FieldType.newBuilder()
-                    .withName(CommonData.defaultSparseVectorField)
-                    .withDataType(DataType.SparseFloatVector)
-                    .build();
-    CollectionSchemaParam collectionSchemaParam = CollectionSchemaParam.newBuilder()
-            .addFieldType(fieldType1)
-            .addFieldType(fieldType2)
-            .addFieldType(fieldType3)
-            .addFieldType(fieldType4)
-            .addFieldType(fieldType5)
-            .build();
-    CreateCollectionParam createCollectionReq =
-            CreateCollectionParam.newBuilder()
-                    .withCollectionName(multiVectorCollection)
-                    .withDescription("Test" + multiVectorCollection + "search")
-                    .withShardsNum(1)
-                    .withSchema(collectionSchemaParam)
-                    .build();
-    R<RpcStatus> collection = BaseTest.milvusClient.createCollection(createCollectionReq);
-    Assert.assertEquals(collection.getStatus().toString(), "0");
-    Assert.assertEquals(collection.getData().getMsg(), "Success");
-  }
 
 
 }

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

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

tests/milvustest/src/test/java/com/zilliz/milvustest/database/DatabaseTest.java

@@ -89,12 +89,13 @@ public class DatabaseTest extends BaseTest {
                             .withDatabaseName(CommonData.databaseName2).build());
         }
         milvusClient.dropDatabase(DropDatabaseParam.newBuilder().withDatabaseName(CommonData.databaseName2).build());
+        milvusClient.dropDatabase(DropDatabaseParam.newBuilder().withDatabaseName(CommonData.databaseName3).build());
     }
 
     @Severity(SeverityLevel.BLOCKER)
     @Test(description = "create database",groups = {"Smoke"})
     public void createDatabase(){
-        R<RpcStatus> database = milvusClient.createDatabase(CreateDatabaseParam.newBuilder().withDatabaseName(CommonData.databaseName2).build());
+        R<RpcStatus> database = milvusClient.createDatabase(CreateDatabaseParam.newBuilder().withDatabaseName(CommonData.databaseName3).build());
         Assert.assertEquals(database.getStatus().toString(), "0");
         Assert.assertEquals(database.getData().getMsg(), "Success");
     }

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

@@ -189,8 +189,8 @@ public class RangeSearchTest extends BaseTest {
                         .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
                         .build();
         R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-        Assert.assertEquals(searchResultsR.getStatus().intValue(), 1100);
-        Assert.assertTrue(searchResultsR.getException().getMessage().contains("range_filter must be greater than radius"));
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 65535);
+        Assert.assertTrue(searchResultsR.getException().getMessage().contains("must be greater than radius"));
     }
 
 
@@ -292,8 +292,8 @@ public class RangeSearchTest extends BaseTest {
                         .withConsistencyLevel(ConsistencyLevelEnum.BOUNDED)
                         .build();
         R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-        Assert.assertEquals(searchResultsR.getStatus().intValue(), 1100);
-        Assert.assertTrue(searchResultsR.getException().getMessage().contains("range_filter must be less than radius"));
+        Assert.assertEquals(searchResultsR.getStatus().intValue(), 65535);
+        Assert.assertTrue(searchResultsR.getException().getMessage().contains("must be less than radius"));
     }
 
 

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

@@ -83,9 +83,9 @@ public class SearchIteratorTest extends BaseTest {
     @DataProvider(name = "testData") // nq,topK,batchSize,expected1,expect2
     public Object[][] provideDataWithExpect(){
         return new Object[][]{
-                {1,1,10L,1,0},
-                {1,50,50L,50,0},
                 {1,50,10L,10,10},
+                {1,1,10L,1,0},
+                {1,20,20L,20,0},
                 {1,50,10000L,50,0}
         };
     }
@@ -114,7 +114,7 @@ public class SearchIteratorTest extends BaseTest {
         long start = System.currentTimeMillis();
         R<SearchIterator> searchIteratorR = milvusClient.searchIterator(SearchIteratorParam.newBuilder()
                 .withCollectionName(collectionWithBinaryVector)
-                .withMetricType(MetricType.JACCARD)
+                .withMetricType(MetricType.HAMMING)
                 .withOutFields(Lists.newArrayList("*"))
                 .withTopK(topK)
                 .withVectorFieldName(CommonData.defaultBinaryVectorField)

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

@@ -1,4 +1,4 @@
-milvusHost=127.0.0.1
+milvusHost=10.102.9.177
 milvusPort=19530
 ScenarioDesc=CI
 BuildId=1d
@@ -7,7 +7,7 @@ SDKBranch=Master
 milvusV=2.2.2
 milvusJdkJavaV=2.2.0
 #minio
-minioHost=http://127.0.0.1:9000
+minioHost=http://10.102.6.207:9000
 accesskey=minioadmin
 secretkey=minioadmin
 #https://devops.apiserver.zilliz.cc:6443

tests/milvustestv2/pom.xml

@@ -73,7 +73,7 @@
         <dependency>
             <groupId>io.milvus</groupId>
             <artifactId>milvus-sdk-java</artifactId>
-            <version>2.3.5</version>
+            <version>2.4.0</version>
         </dependency>
         <dependency>
             <groupId>com.google.protobuf</groupId>
@@ -95,7 +95,11 @@
             <artifactId>okhttp</artifactId>
             <version>4.9.0</version>
         </dependency>
-
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>3.6.1</version>
+        </dependency>
     </dependencies>
     <build>
         <finalName>${project.name}</finalName>

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

@@ -7,6 +7,7 @@ import com.zilliz.milvustestv2.utils.PropertyFilesUtil;
 import io.milvus.param.MetricType;
 import io.milvus.v2.client.ConnectConfig;
 import io.milvus.v2.client.MilvusClientV2;
+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;
@@ -48,19 +49,31 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
         logger.info("**************************************************BeforeSuit**********************");
         milvusClientV2.dropAlias(DropAliasReq.builder().alias(CommonData.alias).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
-        initCollectionForTest();
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultBFloat16VectorCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloat16VectorCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultBinaryVectorCollection).build());
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultSparseFloatVectorCollection).build());
+        initFloatVectorCollectionForTest();
+        initBF16VectorForTest();
+        initFloat16VectorForTest();
+        initSparseVectorForTest();
+        initBinaryVectorForTest();
     }
     @AfterSuite(alwaysRun = true)
     public void cleanTestData() {
         logger.info("**************************************************AfterSuit**********************");
-        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
+//        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
+//        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultBFloat16VectorCollection).build());
+//        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultFloat16VectorCollection).build());
+//        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultBinaryVectorCollection).build());
+//        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(CommonData.defaultSparseFloatVectorCollection).build());
     }
 
-    public  void initCollectionForTest(){
-        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultFloatVectorCollection);
+    public  void initFloatVectorCollectionForTest(){
+        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultFloatVectorCollection, DataType.FloatVector);
         milvusClientV2.createAlias(CreateAliasReq.builder().collectionName(CommonData.defaultFloatVectorCollection).alias(CommonData.alias).build());
         // insert data
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         InsertResp insert = milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).data(jsonObjects).build());
         CommonFunction.createVectorIndex(CommonData.defaultFloatVectorCollection,CommonData.fieldFloatVector, IndexParam.IndexType.AUTOINDEX, IndexParam.MetricType.L2);
         milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(CommonData.defaultFloatVectorCollection).build());
@@ -69,12 +82,30 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
        CommonFunction.createPartition(CommonData.defaultFloatVectorCollection,CommonData.partitionNameA);
        CommonFunction.createPartition(CommonData.defaultFloatVectorCollection,CommonData.partitionNameB);
        CommonFunction.createPartition(CommonData.defaultFloatVectorCollection,CommonData.partitionNameC);
-        List<JsonObject> jsonObjectsA = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
-        List<JsonObject> jsonObjectsB = CommonFunction.generateDefaultData(CommonData.numberEntities*2, CommonData.dim);
-        List<JsonObject> jsonObjectsC = CommonFunction.generateDefaultData(CommonData.numberEntities*3, CommonData.dim);
+        List<JsonObject> jsonObjectsA = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
+        List<JsonObject> jsonObjectsB = CommonFunction.generateDefaultData(CommonData.numberEntities*2, CommonData.dim,DataType.FloatVector);
+        List<JsonObject> jsonObjectsC = CommonFunction.generateDefaultData(CommonData.numberEntities*3, CommonData.dim,DataType.FloatVector);
        milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameA).data(jsonObjectsA).build());
        milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameB).data(jsonObjectsB).build());
        milvusClientV2.insert(InsertReq.builder().collectionName(CommonData.defaultFloatVectorCollection).partitionName(CommonData.partitionNameC).data(jsonObjectsC).build());
     }
 
+    public void initBF16VectorForTest(){
+        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultBFloat16VectorCollection, DataType.BFloat16Vector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultBFloat16VectorCollection,DataType.BFloat16Vector,true,CommonData.numberEntities);
+    }
+    public void initFloat16VectorForTest(){
+        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultFloat16VectorCollection, DataType.Float16Vector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultFloat16VectorCollection,DataType.Float16Vector,true,CommonData.numberEntities);
+    }
+    public void initBinaryVectorForTest(){
+        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultBinaryVectorCollection, DataType.BinaryVector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultBinaryVectorCollection,DataType.BinaryVector,true,CommonData.numberEntities);
+    }
+
+    public void initSparseVectorForTest(){
+        CommonFunction.createNewCollection(CommonData.dim,CommonData.defaultSparseFloatVectorCollection, DataType.SparseFloatVector);
+        CommonFunction.createIndexAndInsertAndLoad(CommonData.defaultSparseFloatVectorCollection,DataType.SparseFloatVector,true,CommonData.numberEntities);
+    }
+
 }

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

@@ -8,9 +8,14 @@ public class CommonData {
     public static long numberEntities=2000;
     public static int dim=128;
     public static String defaultFloatVectorCollection="FloatVectorCollection";
+    public static String defaultBinaryVectorCollection="BinaryVectorCollection";
+    public static String defaultFloat16VectorCollection="Float16VectorCollection";
+    public static String defaultBFloat16VectorCollection="BFloat16VectorCollection";
+    public static String defaultSparseFloatVectorCollection="SparseFloatVectorCollection";
     public static String partitionNameA="partitionNameA";
     public static String partitionNameB="partitionNameB";
     public static String partitionNameC="partitionNameC";
+    public static String defaultPartitionName="_default";
     public static String fieldInt64="fieldInt64";
     public static String fieldInt32="fieldInt32";
     public static String fieldInt16="fieldInt16";
@@ -22,6 +27,11 @@ public class CommonData {
     public static String fieldFloat="fieldFloat";
     public static String fieldJson="fieldJson";
     public static String fieldFloatVector="fieldFloatVector";
+    public static String fieldBinaryVector="fieldBinaryVector";
+    public static String fieldFloat16Vector="fieldFloat16Vector";
+    public static String fieldBF16Vector="fieldBF16Vector";
+    public static String fieldSparseVector="fieldSparseVector";
+
     public static String partitionName="partitionName";
     // 快速创建时候的默认向量filed
     public static String simpleVector="vector";
@@ -29,7 +39,7 @@ public class CommonData {
     public static String alias="ColAlias";
 
     public static int topK=10;
-    public static int nq=5;
+    public static int nq=1;
 
     public static String rootUser="root";
 

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

@@ -2,21 +2,32 @@ package com.zilliz.milvustestv2.common;
 
 import com.google.gson.*;
 import com.google.common.collect.Lists;
+import com.zilliz.milvustestv2.params.FieldParam;
 import com.zilliz.milvustestv2.utils.GenerateUtil;
 
 
+import com.zilliz.milvustestv2.utils.JsonObjectUtil;
+import com.zilliz.milvustestv2.utils.MathUtil;
 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.request.DescribeCollectionReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.collection.response.DescribeCollectionResp;
 import io.milvus.v2.service.index.request.CreateIndexReq;
 import io.milvus.v2.service.partition.request.CreatePartitionReq;
+import io.milvus.v2.service.vector.request.AnnSearchReq;
+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.request.data.FloatVec;
+import io.milvus.v2.service.vector.request.data.*;
+import io.milvus.v2.service.vector.response.InsertResp;
 import io.milvus.v2.service.vector.response.SearchResp;
+import lombok.NonNull;
 import lombok.extern.slf4j.Slf4j;
 
+import javax.annotation.Nullable;
+import java.nio.ByteBuffer;
 import java.util.*;
 
 /**
@@ -27,77 +38,95 @@ import java.util.*;
 public class CommonFunction {
 
     /**
-     * 创建float类型向量的collection
-     * @param dim 维度
+     * 创建DataType vectorType类型向量的collection
+     *
+     * @param dim            维度
      * @param collectionName collection name
+     * @param vectorType     向量类型-sparse vector 不需要dim
      * @return collection name
      */
-    public static String createNewCollection(int dim, String collectionName) {
-        if(collectionName==null){
+    public static String createNewCollection(int dim, String collectionName, DataType vectorType) {
+        if (collectionName == null || collectionName.equals("")) {
             collectionName = "Collection_" + GenerateUtil.getRandomString(10);
         }
-        CreateCollectionReq.FieldSchema fieldInt64=CreateCollectionReq.FieldSchema.builder()
+        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()
-                .dataType(DataType.FloatVector)
-                .name(CommonData.fieldFloatVector)
+        CreateCollectionReq.FieldSchema fieldVector = CreateCollectionReq.FieldSchema.builder()
+                .dataType(vectorType)
                 .isPrimaryKey(false)
-                .dimension(dim)
                 .build();
-
-        List<CreateCollectionReq.FieldSchema> fieldSchemaList=new ArrayList<>();
+        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);
@@ -108,8 +137,8 @@ public class CommonFunction {
         fieldSchemaList.add(fieldBool);
         fieldSchemaList.add(fieldJson);
         fieldSchemaList.add(fieldVarchar);
-        fieldSchemaList.add(fieldFloatVector);
-        CreateCollectionReq.CollectionSchema collectionSchema= CreateCollectionReq.CollectionSchema.builder()
+        fieldSchemaList.add(fieldVector);
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
                 .fieldSchemaList(fieldSchemaList)
                 .build();
         CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
@@ -125,40 +154,57 @@ public class CommonFunction {
     }
 
     /**
-     * 为float类型向量的collection提供导入的数据，目前只支持行式插入
+     * 为不同类型向量的collection提供导入的数据，目前只支持行式插入
+     *
      * @param num 数据量
      * @param dim 维度
      * @return List<JsonObject>
      */
-    public static List<JsonObject> generateDefaultData(long num,int dim){
-        List<JsonObject> jsonList=new ArrayList<>();
+    public static List<JsonObject> generateDefaultData(long num, int dim, DataType vectorType) {
+        List<JsonObject> jsonList = new ArrayList<>();
         Random ran = new Random();
         Gson gson = new Gson();
         for (long i = 0; i < num; i++) {
-            JsonObject row=new JsonObject();
-            row.addProperty(CommonData.fieldInt64,i);
-            row.addProperty(CommonData.fieldInt32,(int)i%32767);
-            row.addProperty(CommonData.fieldInt16,(int)i%32767);
-            row.addProperty(CommonData.fieldInt8,(short)i%127);
-            row.addProperty(CommonData.fieldDouble,(double)i);
-            row.add(CommonData.fieldArray, gson.toJsonTree(Arrays.asList(i,i+1,i+2)));
+            JsonObject row = new JsonObject();
+            row.addProperty(CommonData.fieldInt64, i);
+            row.addProperty(CommonData.fieldInt32, (int) i % 32767);
+            row.addProperty(CommonData.fieldInt16, (int) i % 32767);
+            row.addProperty(CommonData.fieldInt8, (short) i % 127);
+            row.addProperty(CommonData.fieldDouble, (double) i);
+            row.add(CommonData.fieldArray, gson.toJsonTree(Arrays.asList(i, i + 1, i + 2)));
             row.addProperty(CommonData.fieldBool, i % 2 == 0);
-            row.addProperty(CommonData.fieldVarchar,"Str"+i);
-            row.addProperty(CommonData.fieldFloat,(float)i);
-            List<Float> vector=new ArrayList<>();
-            for (int k = 0; k < dim; ++k) {
-                vector.add(ran.nextFloat());
+            row.addProperty(CommonData.fieldVarchar, "Str" + i);
+            row.addProperty(CommonData.fieldFloat, (float) i);
+            // 判断vectorType
+            if (vectorType == DataType.FloatVector) {
+                List<Float> vector = new ArrayList<>();
+                for (int k = 0; k < dim; ++k) {
+                    vector.add(ran.nextFloat());
+                }
+                row.add(CommonData.fieldFloatVector, gson.toJsonTree(vector));
+            }
+            if (vectorType == DataType.BinaryVector) {
+                row.add(CommonData.fieldBinaryVector, gson.toJsonTree(generateBinaryVector(dim).array()));
+            }
+            if (vectorType == DataType.Float16Vector) {
+                row.add(CommonData.fieldFloat16Vector, gson.toJsonTree(generateFloat16Vector(dim).array()));
+            }
+            if (vectorType == DataType.BFloat16Vector) {
+                row.add(CommonData.fieldBF16Vector, gson.toJsonTree(generateBF16Vector(dim).array()));
             }
-            row.add(CommonData.fieldFloatVector, gson.toJsonTree(vector));
+            if (vectorType == DataType.SparseFloatVector) {
+                row.add(CommonData.fieldSparseVector, gson.toJsonTree(generateSparseVector(dim)));
+            }
+
             JsonObject json = new JsonObject();
-            json.addProperty(CommonData.fieldInt64,(int)i%32767);
-            json.addProperty(CommonData.fieldInt32,(int)i%32767);
-            json.addProperty(CommonData.fieldDouble,(double)i);
-            json.add(CommonData.fieldArray, gson.toJsonTree(Arrays.asList(i,i+1,i+2)));
+            json.addProperty(CommonData.fieldInt64, (int) i % 32767);
+            json.addProperty(CommonData.fieldInt32, (int) i % 32767);
+            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);
-            json.addProperty(CommonData.fieldVarchar,"Str"+i);
-            json.addProperty(CommonData.fieldFloat,(float)i);
-            row.add(CommonData.fieldJson,json);
+            json.addProperty(CommonData.fieldVarchar, "Str" + i);
+            json.addProperty(CommonData.fieldFloat, (float) i);
+            row.add(CommonData.fieldJson, json);
             jsonList.add(row);
         }
         return jsonList;
@@ -166,18 +212,19 @@ public class CommonFunction {
 
     /**
      * 为快速生成的collection提供导入数据
+     *
      * @param num 数据量
      * @param dim 维度
      * @return List<JsonObject>
      */
-    public static List<JsonObject> generateSimpleData(long num,int dim){
-        List<JsonObject> jsonList=new ArrayList<>();
+    public static List<JsonObject> generateSimpleData(long num, int dim) {
+        List<JsonObject> jsonList = new ArrayList<>();
         Random ran = new Random();
         Gson gson = new Gson();
         for (long i = 0; i < num; i++) {
             JsonObject row = new JsonObject();
             row.addProperty(CommonData.simplePk, i);
-            List<Float> vector=new ArrayList<>();
+            List<Float> vector = new ArrayList<>();
             for (int k = 0; k < dim; ++k) {
                 vector.add(ran.nextFloat());
             }
@@ -189,12 +236,13 @@ public class CommonFunction {
 
     /**
      * 快速创建一个collection，只有主键和向量字段
-     * @param dim 维度
+     *
+     * @param dim            维度
      * @param collectionName collection name
      * @return collectionName
      */
-    public static String createSimpleCollection(int dim,String collectionName){
-        if(collectionName==null){
+    public static String createSimpleCollection(int dim, String collectionName) {
+        if (collectionName == null) {
             collectionName = "Collection_" + GenerateUtil.getRandomString(10);
         }
         BaseTest.milvusClientV2.createCollection(CreateCollectionReq.builder()
@@ -208,34 +256,37 @@ public class CommonFunction {
 
     /**
      * 创建索引时，提供额外的参数
+     *
      * @param indexType 索引类型
      * @return Map类型参数
      */
-    public static Map<String,Object> provideExtraParam(IndexParam.IndexType indexType){
-        Map<String,Object> map=new HashMap<>();
-        switch (indexType){
+    public static Map<String, Object> provideExtraParam(IndexParam.IndexType indexType) {
+        Map<String, Object> map = new HashMap<>();
+        switch (indexType) {
             case FLAT:
             case AUTOINDEX:
                 break;
             case HNSW:
-                map.put("M",16);
-                map.put("efConstruction",64);
+                map.put("M", 16);
+                map.put("efConstruction", 64);
                 break;
             default:
-                map.put("nlist",128);
+                map.put("nlist", 128);
                 break;
         }
         return map;
     }
 
+
     /**
      * 创建向量索引
+     *
      * @param collectionName collectionName
-     * @param vectorName 向量名称
-     * @param indexType indexType
-     * @param metricType metricType
+     * @param vectorName     向量名称
+     * @param indexType      indexType
+     * @param metricType     metricType
      */
-    public static void createVectorIndex(String collectionName,String vectorName, IndexParam.IndexType indexType, IndexParam.MetricType metricType){
+    public static void createVectorIndex(String collectionName, String vectorName, IndexParam.IndexType indexType, IndexParam.MetricType metricType) {
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(vectorName)
                 .indexType(indexType)
@@ -250,13 +301,14 @@ public class CommonFunction {
 
     /**
      * 创建标量索引
+     *
      * @param collectionName collectionName
-     * @param scalarName 多个标量名称的集合
+     * @param scalarName     多个标量名称的集合
      */
-    public static void createScalarIndex(String collectionName,List<String> scalarName){
+    public static void createScalarIndex(String collectionName, List<String> scalarName) {
         List<IndexParam> indexParams = new ArrayList<>();
-        scalarName.forEach(x->{
-            IndexParam indexParam=IndexParam.builder().indexType(IndexParam.IndexType.TRIE).fieldName(x).build();
+        scalarName.forEach(x -> {
+            IndexParam indexParam = IndexParam.builder().indexType(IndexParam.IndexType.TRIE).fieldName(x).build();
             indexParams.add(indexParam);
         });
         BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
@@ -266,17 +318,19 @@ public class CommonFunction {
     }
 
 
-    public static void createPartition(String collectionName,String partitionName){
+    public static void createPartition(String collectionName, String partitionName) {
         BaseTest.milvusClientV2.createPartition(CreatePartitionReq.builder()
                 .collectionName(collectionName)
                 .partitionName(partitionName)
                 .build());
     }
 
-    public static SearchResp defaultSearch(String collectionName){
+    public static SearchResp defaultSearch(String collectionName) {
         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));
+        });
         return BaseTest.milvusClientV2.search(SearchReq.builder()
                 .collectionName(collectionName)
                 .outputFields(Lists.newArrayList("*"))
@@ -287,5 +341,593 @@ public class CommonFunction {
                 .build());
     }
 
+    /**
+     * 创建一条Sparse向量数据
+     *
+     * @param dim 维度，sparse不需要指定维度，所以方法里随机
+     * @return SortedMap<Long, Float>
+     */
+    public static SortedMap<Long, Float> generateSparseVector(int dim) {
+        Random ran = new Random();
+        SortedMap<Long, Float> sparse = new TreeMap<>();
+        int dimNum = ran.nextInt(dim) + 1;
+        for (int i = 0; i < dimNum; ++i) {
+            sparse.put((long) ran.nextInt(1000000), ran.nextFloat());
+        }
+        return sparse;
+    }
+
+    /**
+     * 创建多条Sparse向量数据
+     *
+     * @param dim 维度，sparse不需要指定维度，所以方法里随机
+     * @return List<SortedMap < Long, Float>>
+     */
+    public static List<SortedMap<Long, Float>> generateSparseVectors(int dim, long count) {
+        List<SortedMap<Long, Float>> list = new ArrayList<>();
+        for (int n = 0; n < count; ++n) {
+            list.add(generateSparseVector(dim));
+        }
+        return list;
+    }
+
+    /**
+     * 创建一条float16的向量
+     *
+     * @param dim 维度
+     * @return ByteBuffer
+     */
+    public static ByteBuffer generateFloat16Vector(int dim) {
+        Random ran = new Random();
+        int byteCount = dim * 2;
+        ByteBuffer vector = ByteBuffer.allocate(byteCount);
+        for (int i = 0; i < dim; ++i) {
+            short halfFloatValue = MathUtil.floatToFloat16(ran.nextInt(100) + 0.1f);
+            ByteBuffer buffer = ByteBuffer.allocate(2);
+            buffer.putShort(halfFloatValue);
+            buffer.flip();
+            vector.put(buffer.get(0));
+            vector.put(buffer.get(1));
+        }
+        return vector;
+    }
+
+    /**
+     * 创建指定数量的float16的向量
+     *
+     * @param dim   维度
+     * @param count 指定条数
+     * @return List<ByteBuffer>
+     */
+    public static List<ByteBuffer> generateFloat16Vectors(int dim, long count) {
+        List<ByteBuffer> vectors = new ArrayList<>();
+        for (int n = 0; n < count; ++n) {
+            vectors.add(generateFloat16Vector(dim));
+        }
+        return vectors;
+    }
+
+    /**
+     * 创建一条BF16的向量
+     *
+     * @param dim
+     * @return ByteBuffer
+     */
+    public static ByteBuffer generateBF16Vector(int dim) {
+        Random ran = new Random();
+        float randomFloat;
+        int byteCount = dim * 2;
+        ByteBuffer vector = ByteBuffer.allocate(byteCount);
+        for (int i = 0; i < dim; ++i) {
+            do {
+                randomFloat = ran.nextFloat();
+            } while (Float.isInfinite(randomFloat));
+            short halfFloatValue = MathUtil.floatToBF16(randomFloat);
+            ByteBuffer buffer = ByteBuffer.allocate(2);
+            buffer.putShort(halfFloatValue);
+            buffer.flip();
+            vector.put(buffer.get(0));
+            vector.put(buffer.get(1));
+        }
+        return vector;
+    }
+
+    /**
+     * 创建指定数量的BF16的向量
+     *
+     * @param dim
+     * @param count
+     * @return List<ByteBuffer>
+     */
+    public static List<ByteBuffer> generateBF16Vectors(int dim, long count) {
+        List<ByteBuffer> vectors = new ArrayList<>();
+        for (int n = 0; n < count; ++n) {
+            vectors.add(generateBF16Vector(dim));
+        }
+        return vectors;
+    }
+
+    /**
+     * 生成一条binary向量
+     *
+     * @param dim 维度
+     * @return ByteBuffer
+     */
+    public static ByteBuffer generateBinaryVector(int dim) {
+        Random ran = new Random();
+        int byteCount = dim / 8;
+        ByteBuffer vector = ByteBuffer.allocate(byteCount);
+        for (int i = 0; i < byteCount; ++i) {
+            vector.put((byte) ran.nextInt(Byte.MAX_VALUE));
+        }
+        return vector;
+    }
+
+
+    /**
+     * 生成指定数量的binary向量数据
+     *
+     * @param count binary向量的数据条数
+     * @param dim   维度
+     * @return List<ByteBuffer>
+     */
+    public static List<ByteBuffer> generateBinaryVectors(int dim, long count) {
+        List<ByteBuffer> vectors = new ArrayList<>();
+        for (int n = 0; n < count; ++n) {
+            vectors.add(generateBinaryVector(dim));
+        }
+        return vectors;
+    }
+
+    private static JsonArray toJsonArray(byte[] bytes) {
+        JsonArray jsonArray = new JsonArray();
+        for (byte b : bytes) {
+            jsonArray.add(b);
+        }
+        return jsonArray;
+    }
+
+    /**
+     * 创建索引
+     *
+     * @param collection collection name
+     * @param vectorType 向量类型
+     */
+    public static void createIndex(String collection, DataType vectorType) {
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(provideFieldVectorName(vectorType))
+                .indexType(IndexParam.IndexType.AUTOINDEX)
+                .extraParams(CommonFunction.provideExtraParam(IndexParam.IndexType.AUTOINDEX))
+                .metricType(provideMetricTypeByVectorType(vectorType))
+                .build();
+        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(collection)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+    }
+
+    /**
+     * 更具向量类型提供MetricType
+     *
+     * @param vectorType 向量类型
+     * @return MetricType
+     */
+    public static IndexParam.MetricType provideMetricTypeByVectorType(DataType vectorType) {
+        switch (vectorType.getCode()) {
+            case 101:
+            case 102:
+            case 103:
+                return IndexParam.MetricType.L2;
+            case 100:
+                return IndexParam.MetricType.HAMMING;
+            case 104:
+                return IndexParam.MetricType.IP;
+            default:
+                return IndexParam.MetricType.INVALID;
+        }
+    }
+
+    /**
+     * 更具向量类型提供向量name
+     *
+     * @param vectorType 向量类型
+     * @return vector field name
+     */
+    public static String provideFieldVectorName(DataType vectorType) {
+        switch (vectorType.getCode()) {
+            case 101:
+                return CommonData.fieldFloatVector;
+            case 102:
+                return CommonData.fieldFloat16Vector;
+            case 103:
+                return CommonData.fieldBF16Vector;
+            case 100:
+                return CommonData.fieldBinaryVector;
+            case 104:
+                return CommonData.fieldSparseVector;
+            default:
+                return "";
+        }
+    }
+
+    /**
+     * collection建索引+insert+load
+     *
+     * @param collectionName collection name
+     * @param vectorType     向量类型
+     * @param ifLoad         是否load
+     */
+    public static void createIndexAndInsertAndLoad(String collectionName, DataType vectorType, @NonNull Boolean ifLoad, Long numberEntities) {
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(provideFieldVectorName(vectorType))
+                .indexType(providerIndexType(vectorType))
+                .extraParams(CommonFunction.provideExtraParam(providerIndexType(vectorType)))
+                .metricType(provideMetricTypeByVectorType(vectorType))
+                .build();
+        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(collectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+        if (ifLoad) {
+            BaseTest.milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(collectionName).build());
+        }
+        List<JsonObject> jsonObjects = generateDefaultData(numberEntities, CommonData.dim, vectorType);
+        InsertResp insert = BaseTest.milvusClientV2.insert(InsertReq.builder().collectionName(collectionName).data(jsonObjects).build());
+        System.out.println(insert);
+
+    }
+
+    /**
+     * 提供search时候的向量参数
+     *
+     * @param nq         向量个数
+     * @param dim        维度
+     * @param vectorType 向量类型
+     * @return List<BaseVector>
+     */
+    public static List<BaseVector> providerBaseVector(int nq, int dim, DataType vectorType) {
+        List<BaseVector> data = new ArrayList<>();
+        if (vectorType.equals(DataType.FloatVector)) {
+            List<List<Float>> lists = GenerateUtil.generateFloatVector(nq, 3, dim);
+            lists.forEach((v) -> {
+                data.add(new FloatVec(v));
+            });
+        }
+        if (vectorType.equals(DataType.BinaryVector)) {
+            List<ByteBuffer> byteBuffers = generateBinaryVectors(dim, nq);
+            byteBuffers.forEach(x -> {
+                data.add(new BinaryVec(x));
+            });
+        }
+        if (vectorType.equals(DataType.Float16Vector)) {
+            List<ByteBuffer> byteBuffers = generateFloat16Vectors(dim, nq);
+            byteBuffers.forEach(x -> {
+                data.add(new Float16Vec(x));
+            });
+        }
+        if (vectorType.equals(DataType.BFloat16Vector)) {
+            List<ByteBuffer> byteBuffers = generateBF16Vectors(dim, nq);
+            byteBuffers.forEach(x -> {
+                data.add(new BFloat16Vec(x));
+            });
+        }
+        if (vectorType.equals(DataType.SparseFloatVector)) {
+            List<SortedMap<Long, Float>> list = generateSparseVectors(dim, nq);
+            list.forEach(x -> {
+                data.add(new SparseFloatVec(x));
+            });
+        }
+        return data;
+
+    }
+
+    /**
+     * 根据向量类型决定IndexType
+     *
+     * @param vectorType DataType
+     * @return IndexParam.IndexType
+     */
+    public static IndexParam.IndexType providerIndexType(DataType vectorType) {
+        switch (vectorType.getCode()) {
+            case 101:
+                return IndexParam.IndexType.HNSW;
+            case 102:
+                return IndexParam.IndexType.HNSW;
+            case 103:
+                return IndexParam.IndexType.HNSW;
+            case 100:
+                return IndexParam.IndexType.BIN_IVF_FLAT;
+            case 104:
+                return IndexParam.IndexType.SPARSE_WAND;
+            default:
+                return IndexParam.IndexType.TRIE;
+        }
+    }
+
+
+    /**
+     * 创建通用的collection方法，支持多个filed，多个向量
+     * @param collectionName collection 可不传
+     * @param pkDataType     主键类型
+     * @param enableDynamic  是否开启动态列
+     * @param fieldParamList 其他字段
+     * @return collection name
+     */
+    public static String genCommonCollection(@Nullable String collectionName, DataType pkDataType, boolean enableDynamic, List<FieldParam> fieldParamList) {
+        if (collectionName == null || collectionName.equals("")) {
+            collectionName = "Collection_" + GenerateUtil.getRandomString(10);
+        }
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = parseDataType(fieldParamList);
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
+                .autoID(false)
+                .dataType(pkDataType)
+                .isPrimaryKey(true)
+                .name(pkDataType + "_0")
+                .build();
+        fieldSchemaList.add(fieldInt64);
+
+
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
+                .fieldSchemaList(fieldSchemaList)
+                .build();
+        CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
+                .collectionSchema(collectionSchema)
+                .collectionName(collectionName)
+                .enableDynamicField(enableDynamic)
+                .description("collection desc")
+                .numShards(1)
+                .build();
+        BaseTest.milvusClientV2.createCollection(createCollectionReq);
+        return collectionName;
+    }
+
+    /**
+     * 遍历fieldParamList生成对应的schema
+     * @param fieldParamList field字段集合
+     * @return List<CreateCollectionReq.FieldSchema> 给创建collection提供
+     */
+    public static List<CreateCollectionReq.FieldSchema> parseDataType(List<FieldParam> fieldParamList) {
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
+        for (FieldParam fieldParam : fieldParamList) {
+            //按照_分组
+            DataType dataType = fieldParam.getDataType();
+            CreateCollectionReq.FieldSchema fieldSchema = CreateCollectionReq.FieldSchema.builder()
+                    .dataType(dataType)
+                    .name(fieldParam.getFieldName())
+                    .isPrimaryKey(false)
+                    .build();
+            if (dataType == DataType.FloatVector || dataType == DataType.BFloat16Vector || dataType == DataType.Float16Vector || dataType == DataType.BinaryVector) {
+                fieldSchema.setDimension(fieldParam.getDim());
+            }
+            if (dataType == DataType.String || dataType == DataType.VarChar) {
+                fieldSchema.setMaxLength(fieldParam.getMaxLength());
+            }
+            if (dataType == DataType.Array) {
+                fieldSchema.setMaxCapacity(fieldParam.getMaxCapacity());
+                fieldSchema.setElementType(fieldParam.getElementType());
+            }
+            fieldSchemaList.add(fieldSchema);
+        }
+        return fieldSchemaList;
+    }
+
+
+    /**
+     * 生成通用的数据
+     *
+     * @param collectionName 向量名称
+     * @param count          生成的数量
+     * @return List<JsonObject>
+     */
+    public static List<JsonObject> genCommonData(String collectionName, long count) {
+        DescribeCollectionResp describeCollectionResp = BaseTest.milvusClientV2.describeCollection(DescribeCollectionReq.builder().collectionName(collectionName).build());
+        CreateCollectionReq.CollectionSchema collectionSchema = describeCollectionResp.getCollectionSchema();
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = collectionSchema.getFieldSchemaList();
+        List<JsonObject> jsonList = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            JsonObject row = new JsonObject();
+            for (CreateCollectionReq.FieldSchema fieldSchema : fieldSchemaList) {
+                String name = fieldSchema.getName();
+                DataType dataType = fieldSchema.getDataType();
+                Integer dimension = fieldSchema.getDimension();
+                Integer maxCapacity = fieldSchema.getMaxCapacity();
+                Integer maxLength = fieldSchema.getMaxLength();
+                JsonObject jsonObject;
+                if (dataType == DataType.FloatVector || dataType == DataType.BFloat16Vector || dataType == DataType.Float16Vector || dataType == DataType.BinaryVector) {
+                    jsonObject = generalJsonObjectByDataType(name, dataType, dimension, i);
+                } else if (dataType == DataType.SparseFloatVector) {
+                    jsonObject = generalJsonObjectByDataType(name, dataType, CommonData.dim, i);
+                } else if (dataType == DataType.VarChar || dataType == DataType.String) {
+                    jsonObject = generalJsonObjectByDataType(name, dataType, maxLength, i);
+                } else if (dataType == DataType.Array) {
+                    jsonObject = generalJsonObjectByDataType(name, dataType, maxCapacity, i);
+                } else {
+                    jsonObject = generalJsonObjectByDataType(name, dataType, 0, i);
+                }
+                row = JsonObjectUtil.jsonMerge(row, jsonObject);
+            }
+            jsonList.add(row);
+        }
+        return jsonList;
+    }
+
+    /**
+     * 更具数据类型，创建JsonObject
+     *
+     * @param fieldName   字段名称
+     * @param dataType    类型
+     * @param dimOrLength 向量维度或者array容量或者varchar长度
+     * @param countIndex  索引i，避免多次创建时数据内容一样
+     * @return JsonObject
+     */
+    public static JsonObject generalJsonObjectByDataType(String fieldName, DataType dataType, int dimOrLength, long countIndex) {
+        JsonObject row = new JsonObject();
+        Gson gson = new Gson();
+        Random random = new Random();
+        if (dataType == DataType.Int64) {
+            row.addProperty(fieldName, countIndex);
+        }
+        if (dataType == DataType.Int32) {
+            row.addProperty(fieldName, (int) countIndex % 32767);
+        }
+        if (dataType == DataType.Int16) {
+            row.addProperty(fieldName, (int) countIndex % 32767);
+        }
+        if (dataType == DataType.Int8) {
+            row.addProperty(fieldName, (short) countIndex % 127);
+        }
+        if (dataType == DataType.Double) {
+            row.addProperty(fieldName, (double) countIndex * 0.1f);
+        }
+        if (dataType == DataType.Array) {
+            int i = random.nextInt(dimOrLength);
+            List<Long> arrays = new ArrayList<>();
+            for (int j = 0; j < i; j++) {
+                arrays.add(countIndex + j);
+            }
+            row.add(fieldName, gson.toJsonTree(arrays));
+        }
+        if (dataType == DataType.Bool) {
+            row.addProperty(fieldName, countIndex % 2 == 0);
+        }
+        if (dataType == DataType.VarChar) {
+            int i = random.nextInt(dimOrLength / 2);
+            String s = MathUtil.genRandomStringAndChinese(i);
+            row.addProperty(fieldName, s);
+        }
+        if (dataType == DataType.String) {
+            int i = random.nextInt(dimOrLength / 2);
+            String s = MathUtil.genRandomStringAndChinese(i);
+            row.addProperty(fieldName, s);
+        }
+        if (dataType == DataType.Float) {
+            row.addProperty(fieldName, (float) countIndex * 0.1f);
+        }
+        if (dataType == DataType.FloatVector) {
+            List<Float> vector = new ArrayList<>();
+            for (int k = 0; k < dimOrLength; ++k) {
+                vector.add(random.nextFloat());
+            }
+            row.add(fieldName, gson.toJsonTree(vector));
+        }
+        if (dataType == DataType.BinaryVector) {
+            row.add(fieldName, gson.toJsonTree(generateBinaryVector(dimOrLength).array()));
+        }
+        if (dataType == DataType.Float16Vector) {
+            row.add(fieldName, gson.toJsonTree(generateFloat16Vector(dimOrLength).array()));
+        }
+        if (dataType == DataType.BFloat16Vector) {
+            row.add(fieldName, gson.toJsonTree(generateBF16Vector(dimOrLength).array()));
+        }
+        if (dataType == DataType.SparseFloatVector) {
+            row.add(fieldName, gson.toJsonTree(generateSparseVector(dimOrLength)));
+        }
+        if (dataType == DataType.JSON) {
+            JsonObject json = new JsonObject();
+            json.addProperty(CommonData.fieldInt64, (int) countIndex % 32767);
+            json.addProperty(CommonData.fieldInt32, (int) countIndex % 32767);
+            json.addProperty(CommonData.fieldDouble, (double) countIndex);
+            json.add(CommonData.fieldArray, gson.toJsonTree(Arrays.asList(countIndex, countIndex + 1, countIndex + 2)));
+            json.addProperty(CommonData.fieldBool, countIndex % 2 == 0);
+            json.addProperty(CommonData.fieldVarchar, "Str" + countIndex);
+            json.addProperty(CommonData.fieldFloat, (float) countIndex);
+            row.add(fieldName, json);
+        }
+        return row;
+    }
+
+    /**
+     * 创建通用索引
+     * @param collection   collection name
+     * @param fieldParamList field集合
+     */
+    public static void createCommonIndex(String collection, List<FieldParam> fieldParamList) {
+        List<IndexParam> indexParamList = new ArrayList<>();
+        for (FieldParam fieldParam : fieldParamList) {
+            //按照_分组
+            DataType dataType = fieldParam.getDataType();
+            String fieldName = fieldParam.getFieldName();
+
+            IndexParam indexParam = IndexParam.builder()
+                    .fieldName(fieldName)
+                    .indexType(providerIndexType(dataType))
+                    .extraParams(CommonFunction.provideExtraParam(providerIndexType(dataType)))
+                    .metricType(provideMetricTypeByVectorType(dataType))
+                    .build();
+            indexParamList.add(indexParam);
+        }
+
+        BaseTest.milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(collection)
+                .indexParams(indexParamList)
+                .build());
+    }
+
+
+    /**
+     * 为多向量查询提供AnnSearch
+     * @param fieldParam 字段参数
+     * @param nq 传入的向量数
+     * @param topK 查询数量
+     * @param expr 表达式
+     * @return AnnSearchReq
+     */
+    public static AnnSearchReq provideAnnSearch(FieldParam fieldParam, int nq, int topK, String expr) {
+        DataType dataType = fieldParam.getDataType();
+        int dim = fieldParam.getDim();
+        List<BaseVector> baseVectors = providerBaseVector(nq, dim, dataType);
+        return AnnSearchReq.builder().vectors(baseVectors)
+                .topK(topK)
+                .vectorFieldName(fieldParam.getFieldName())
+                .params(provideSearchParam(providerIndexType(dataType)))
+                .expr(expr).build();
+    }
+
+    /**
+     * 根据索引类型提供查询参数
+     * @param indexType index type
+     * @return String 查询参数
+     */
+    public static String provideSearchParam(IndexParam.IndexType indexType) {
+        String extraParam;
+        switch (indexType) {
+            case FLAT:
+                extraParam = "{}";
+                break;
+            case IVF_FLAT:
+                extraParam = "{\"nlist\":32,\"nprobe\":32}";
+                break;
+            case IVF_SQ8:
+                extraParam = "{\"nlist\":128}";
+                break;
+            case IVF_PQ:
+                extraParam = "{\"nlist\":128, \"m\":16, \"nbits\":8}";
+                break;
+            case HNSW:
+                extraParam = "{\"M\":16,\"efConstruction\":64}";
+                break;
+            case BIN_IVF_FLAT:
+                extraParam = "{\"nlist\": 128}";
+                break;
+            case SCANN:
+                extraParam="{\"nlist\":1024,\"with_raw_data\":"+true+"}";
+                break;
+            case GPU_IVF_FLAT:
+                extraParam="{\"nlist\": 64}";
+                break;
+            case GPU_IVF_PQ:
+                extraParam="{\"nlist\": 64, \"m\": 16, \"nbits\": 8}";
+                break;
+            case SPARSE_INVERTED_INDEX:
+            case SPARSE_WAND:
+                extraParam="{\"drop_ratio_search\":0.2}";
+                break;
+            default:
+                extraParam = "{\"nlist\":128}";
+                break;
+        }
+        return extraParam;
+    }
 }
 
+

tests/milvustestv2/src/main/java/com/zilliz/milvustestv2/params/FieldParam.java

@@ -0,0 +1,17 @@
+package com.zilliz.milvustestv2.params;
+
+import io.milvus.v2.common.DataType;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class FieldParam {
+    String fieldName;
+    DataType dataType;
+    int dim;
+    int maxLength;
+    int maxCapacity;
+    DataType elementType;
+
+}

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

@@ -0,0 +1,65 @@
+package com.zilliz.milvustestv2.utils;
+
+import io.milvus.v2.common.IndexParam;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+public class DataProviderUtils {
+    public static Object[][] generateDataSets(Object[][]... arrays) {
+        Object[][] testData=arrays[0];
+        for (int i = 1; i < arrays.length; i++) {
+            testData=combine(testData,arrays[i]);
+        }
+        return testData;
+    }
+
+
+    public static void main(String[] args) {
+        Object[][] array1 = {{IndexParam.MetricType.L2,"a"}, {IndexParam.MetricType.IP,"b"}, {IndexParam.MetricType.HAMMING,"c"}};
+        Object[][] array2 = {{"1"}, {"2"}, {"3"}};
+        Object[][] array3 = {{"x"}, {"y"}, {"z"}};
+        Object[][] array40 = {{110,1100}, {220,2200}, {330,3300}};
+        Object[][] array4 = {{10,100}, {20,200}, {30,300}};
+        String[] array5 = {"I", "II", "III"};
+
+        Object[][] combine = generateDataSets(array1,array4);
+
+        for (Object[] objects : combine) {
+            for (Object object : objects) {
+                System.out.print(object+" ");
+            }
+            System.out.println("----------");
+        }
+    }
+
+
+
+    public static Object[][] combine(Object[][] a1, Object[][] a2) {
+        List<Object[]> objectCodesList = new LinkedList<>();
+        for (Object[] o : a1) {
+            for (Object[] o2 : a2) {
+                objectCodesList.add(concatAll(o, o2));
+            }
+        }
+        return objectCodesList.toArray(new Object[0][0]);
+    }
+
+    public static <T> T[] concatAll(T[] first, T[]... rest) {
+        // calculate the total length of the final object array after the concat
+        int totalLength = first.length;
+        for (T[] array : rest) {
+            totalLength += array.length;
+        }
+        // copy the first array to result array and then copy each array completely to result
+        T[] result = Arrays.copyOf(first, totalLength);
+        int offset = first.length;
+        for (T[] array : rest) {
+            System.arraycopy(array, 0, result, offset, array.length);
+            offset += array.length;
+        }
+
+        return result;
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.zilliz.milvustestv2.utils;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class JsonObjectUtil {
+
+    public static JsonObject jsonMerge(JsonObject jsonObject1,JsonObject jsonObject2){
+        Gson gson = new Gson();
+        // 将 JsonObject 转换为 Map
+        Map<String, Object> map1 = gson.fromJson(jsonObject1, HashMap.class);
+        Map<String, Object> map2 = gson.fromJson(jsonObject2, HashMap.class);
+
+        // 合并两个 Map
+        Map<String, Object> mergedMap = new HashMap<>(map1);
+        mergedMap.putAll(map2);
+
+        // 将合并后的 Map 转换为 JsonObject
+        JsonObject mergedJsonObject = JsonParser.parseString(gson.toJson(mergedMap)).getAsJsonObject();
+        return mergedJsonObject;
+    }
+}

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

@@ -0,0 +1,266 @@
+package com.zilliz.milvustestv2.utils;
+
+
+import java.io.File;
+import java.math.BigDecimal;
+import java.util.*;
+
+public class MathUtil {
+  public static String getRandomString(int length) {
+    String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    Random random = new Random();
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i < length; i++) {
+      int number = random.nextInt(62);
+      sb.append(str.charAt(number));
+    }
+    return sb.toString();
+  }
+
+  public static boolean delAllFile(String path) {
+    boolean flag = false;
+    File file = new File(path);
+    if (!file.exists()) {
+      return flag;
+    }
+    if (!file.isDirectory()) {
+      return flag;
+    }
+    String[] tempList = file.list();
+    File temp = null;
+    for (int i = 0; i < tempList.length; i++) {
+      if (path.endsWith(File.separator)) {
+        temp = new File(path + tempList[i]);
+      } else {
+        temp = new File(path + File.separator + tempList[i]);
+      }
+      if (temp.isFile()) {
+        temp.delete();
+      }
+      if (temp.isDirectory()) {
+        delAllFile(path + "/" + tempList[i]); // 先删除文件夹里面的文件
+        flag = true;
+      }
+    }
+    return flag;
+  }
+
+  public static Integer[] generateIntPK(int num, Boolean sequence, int fileNumber) {
+    Integer[] intData = new Integer[num];
+    Random random = new Random(num);
+    if (sequence) {
+      for (int i = 0; i < num; i++) {
+        intData[i] = i + num * (fileNumber - 1);
+      }
+    }
+    if (!sequence) {
+      List<Integer> lists = new ArrayList<>();
+      for (int i = 0; i < num; i++) {
+        lists.add(i + num * (fileNumber - 1));
+      }
+      for (int i = 0; i < num; i++) {
+        int index = random.nextInt(lists.size());
+        intData[i] = lists.get(index);
+        lists.remove(index);
+      }
+    }
+    return intData;
+  }
+
+  public static Integer[] generateInt(int num, Boolean sequence) {
+    Integer[] intData = new Integer[num];
+    Random random = new Random(num);
+    if (sequence) {
+      for (int i = 0; i < num; i++) {
+        intData[i] = i;
+      }
+    }
+    if (!sequence) {
+      List<Integer> lists = new ArrayList<>();
+      for (int i = 0; i < num; i++) {
+        lists.add(i);
+      }
+      for (int i = 0; i < num; i++) {
+        int index = random.nextInt(lists.size());
+        intData[i] = lists.get(index);
+        lists.remove(index);
+      }
+    }
+    return intData;
+  }
+
+  public static Float[] generateFloat(int num) {
+    Float[] floats = new Float[num];
+    Random random = new Random(num);
+    for (int i = 0; i < num; i++) {
+      floats[i] = random.nextFloat();
+    }
+    return floats;
+  }
+
+  public static String[] generateString(int num) {
+    String[] strings = new String[num];
+    for (int i = 0; i < num; i++) {
+      strings[i] = getRandomString(15);
+    }
+    return strings;
+  }
+
+  public static List<Double[]> generateFloatVector(int num, int length, int dim) {
+    List<Double[]> doubleList = new ArrayList<>(num);
+    for (int j = 0; j < num; j++) {
+      Double[] doubles = new Double[dim];
+      for (int i = 0; i < dim; i++) {
+        BigDecimal bigDecimal = BigDecimal.valueOf(Math.random());
+        BigDecimal bigDecimal1 = bigDecimal.setScale(length, BigDecimal.ROUND_HALF_UP);
+        doubles[i] = bigDecimal1.doubleValue();
+      }
+      doubleList.add(doubles);
+    }
+    return doubleList;
+  }
+
+  public static List<int[]> generateBinaryVectors(int num, int dim) {
+    Random random=new Random();
+    List<int[]> intList = new ArrayList<>(num);
+    for (int j = 0; j < num; j++) {
+      int[] intvalue = new int[dim/8];
+      for (int i = 0; i < dim/8; i++) {
+
+        intvalue[i] = random.nextInt(100);
+      }
+      intList.add(intvalue);
+    }
+    return intList;
+
+  }
+
+  public static Boolean[] generateBoolean(int num) {
+    Boolean[] booleans = new Boolean[num];
+    Random random = new Random();
+    for (int i = 0; i < num; i++) {
+      if (random.nextInt() % 2 == 0) {
+        booleans[i] = Boolean.TRUE;
+      } else {
+        booleans[i] = Boolean.FALSE;
+      }
+    }
+    return booleans;
+  }
+
+  public static Long[] generateLong(int num) {
+    Long[] longs = new Long[num];
+    Random random = new Random();
+    for (int i = 0; i < num; i++) {
+      longs[i] = random.nextLong();
+    }
+    return longs;
+  }
+
+  public static Object[][] combine(Object[][] a1, Object[][] a2) {
+    List<Object[]> objectCodesList = new LinkedList<Object[]>();
+    for (Object[] o : a1) {
+      for (Object[] o2 : a2) {
+        objectCodesList.add(concatAll(o, o2));
+      }
+    }
+    return objectCodesList.toArray(new Object[0][0]);
+  }
+
+  public static <T> T[] concatAll(T[] first, T[]... rest) {
+    // calculate the total length of the final object array after the concat
+    int totalLength = first.length;
+    for (T[] array : rest) {
+      totalLength += array.length;
+    }
+    // copy the first array to result array and then copy each array completely to result
+    T[] result = Arrays.copyOf(first, totalLength);
+    int offset = first.length;
+    for (T[] array : rest) {
+      System.arraycopy(array, 0, result, offset, array.length);
+      offset += array.length;
+    }
+
+    return result;
+  }
+
+  public static String genRandomStringAndChinese(int length){
+    String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    String chinese="富强民主文明和谐自由平等公正法治爱国敬业诚信友善";
+    String strChinese=str+chinese;
+    Random random = new Random();
+    StringBuffer sb = new StringBuffer();
+    for (int i = 0; i < length; i++) {
+      int number = random.nextInt(strChinese.length());
+      sb.append(strChinese.charAt(number));
+    }
+    return sb.toString();
+  }
+
+  public static float generalRandomLargeThanFloat(float floatNum){
+    Random random=new Random();
+    return random.nextInt(10)+floatNum+1;
+  }
+
+  public static float generalRandomLessThanFloat(float floatNum){
+    Random random=new Random();
+    return floatNum-random.nextInt(5)-1;
+  }
+
+  public static short floatToFloat16(float value) {
+    int f = Float.floatToRawIntBits(value);
+    int s = (f >> 16) & 0x8000;
+    int e = ((f >> 23) & 0xff) - 127;
+    int m = f & 0x7fffff;
+
+    if (e <= -15) {
+      // 如果指数小于等于-15，则将float16值设为0
+      return 0;
+    }
+    if (e > 16) {
+      // 如果指数大于16，则将float16值设为最大值
+      return (short) (s | 0x7bff);
+    }
+    if (e <= 0) {
+      m = (m | 0x800000) >> (1 - e);
+      return (short) (s | (m >> 13));
+    }
+    if (e < 24) {
+      return (short) (s | ((e + 112) << 10) | (m >> 13));
+    }
+
+    return (short) (s | 0x7c00);
+     }
+
+  public static short floatToBF16(float value) {
+    int bits = Float.floatToIntBits(value);
+    int sign = bits >>> 31;
+    int exp = (bits >>> 23) & 0xFF;
+    int mantissa = bits & 0x7FFFFF;
+
+    if (exp == 0xFF) {
+      // 处理无穷大和 NaN
+      if (mantissa == 0) {
+        return (short) ((sign << 15) | 0x7C00);  // 正负无穷
+      } else {
+        return (short) ((sign << 15) | 0x7C00 | (mantissa >>> 13));  // NaN
+      }
+    }
+
+    exp -= 127;
+    exp += 16;
+    if (exp >= 0x1F) {
+      // 处理溢出情况
+      return (short) ((sign << 15) | 0x7C00);
+    } else if (exp <= 0) {
+      // 处理下溢情况
+      return 0;
+    }
+
+    return (short) ((sign << 15) | (exp << 10) | (mantissa >>> 13));
+  }
+
+
+
+
+}

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

@@ -4,6 +4,7 @@ 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 io.milvus.v2.common.DataType;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.utility.request.AlterAliasReq;
 import io.milvus.v2.service.utility.request.CreateAliasReq;
@@ -27,8 +28,8 @@ public class AlterAliasTest extends BaseTest {
     @BeforeClass(alwaysRun = true)
     public void providerCollection() {
         aliasName= GenerateUtil.getRandomString(10);
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        newCollectionName2 = CommonFunction.createNewCollection(CommonData.dim, null);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        newCollectionName2 = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
         milvusClientV2.createAlias(CreateAliasReq.builder()
                 .collectionName(newCollectionName)
                 .alias(aliasName)

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

@@ -5,6 +5,7 @@ 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 io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.index.request.CreateIndexReq;
@@ -31,8 +32,8 @@ public class CreateAliasTest extends BaseTest {
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
         aliasName="a_"+ GenerateUtil.getRandomString(10);
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(CommonData.fieldFloatVector)

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

@@ -4,6 +4,7 @@ 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 io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.index.request.CreateIndexReq;
@@ -31,7 +32,7 @@ public class DropAliasTest extends BaseTest {
     @BeforeClass(alwaysRun = true)
     public void providerCollection() {
         aliasName= GenerateUtil.getRandomString(10);
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
         milvusClientV2.createAlias(CreateAliasReq.builder()
                 .collectionName(newCollectionName)
                 .alias(aliasName)

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

@@ -3,6 +3,7 @@ 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.common.resourcegroup.ResourceGroupConfig;
 import io.milvus.v2.common.DataType;
 import io.milvus.v2.common.IndexParam;
 import io.milvus.v2.service.collection.request.*;
@@ -10,8 +11,10 @@ import io.milvus.v2.service.collection.response.ListCollectionsResp;
 import io.milvus.v2.service.vector.response.SearchResp;
 import org.testng.Assert;
 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;
@@ -33,6 +36,16 @@ public class CreateCollectionTest extends BaseTest {
 
     }
 
+    @DataProvider(name = "VectorTypeList")
+    public Object[][] providerVectorType(){
+        return new Object[][]{
+                {DataType.FloatVector},
+                {DataType.BinaryVector},
+                {DataType.Float16Vector},
+                {DataType.BFloat16Vector},
+                {DataType.SparseFloatVector},
+        };
+    }
     @Test(description = "Create simple collection success", groups = {"Smoke"})
     public void createSimpleCollectionSuccess(){
         milvusClientV2.createCollection(CreateCollectionReq.builder()
@@ -43,7 +56,6 @@ public class CreateCollectionTest extends BaseTest {
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
         Assert.assertTrue(listCollectionsResp.getCollectionNames().contains("simpleCollection"));
     }
-
     @Test(description = "Create duplicate collection", groups = {"Smoke"})
     public void createDuplicateSimpleCollection(){
         milvusClientV2.createCollection(CreateCollectionReq.builder()
@@ -158,10 +170,18 @@ public class CreateCollectionTest extends BaseTest {
         ListCollectionsResp listCollectionsResp = milvusClientV2.listCollections();
         Assert.assertTrue(listCollectionsResp.getCollectionNames().contains(collectionNameWithIndex));
         //insert
-        CommonFunction.generateDefaultData(100,CommonData.dim);
+        CommonFunction.generateDefaultData(100,CommonData.dim,DataType.FloatVector);
         // search
         SearchResp searchResp = CommonFunction.defaultSearch(collectionNameWithIndex);
         Assert.assertEquals(searchResp.getSearchResults().size(),10);
     }
 
+    @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));
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+    }
+
 }

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

@@ -2,6 +2,7 @@ package com.zilliz.milvustestv2.collection;
 
 import com.zilliz.milvustestv2.common.BaseTest;
 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 org.testng.Assert;
@@ -17,7 +18,7 @@ public class DropCollectionTest extends BaseTest {
 
     @DataProvider(name = "initCollection")
     public Object[][] providerCollection(){
-        String newCollection = CommonFunction.createNewCollection(128, null);
+        String newCollection = CommonFunction.createNewCollection(128, null, DataType.FloatVector);
         return new Object[][]{{newCollection}};
     }
 

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

@@ -4,6 +4,7 @@ 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.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.collection.request.GetCollectionStatsReq;
 import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
@@ -24,8 +25,8 @@ public class GetCollectionStatsTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
     }
 

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

@@ -4,6 +4,7 @@ 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 io.milvus.v2.common.DataType;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.collection.request.RenameCollectionReq;
 import io.milvus.v2.service.collection.response.ListCollectionsResp;
@@ -18,7 +19,7 @@ public class RenameCollectionTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
     }
 
     @AfterClass(alwaysRun = true)

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

@@ -5,6 +5,7 @@ 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.common.IndexParam;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.collection.request.LoadCollectionReq;
@@ -26,8 +27,8 @@ public class CreateIndexTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
     }
 

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

@@ -4,6 +4,7 @@ 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.index.request.CreateIndexReq;
@@ -26,8 +27,8 @@ public class DescribeIndexTest extends BaseTest {
        String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(CommonData.fieldFloatVector)

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

@@ -4,6 +4,7 @@ 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.index.request.CreateIndexReq;
@@ -24,8 +25,8 @@ public class DropIndexTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(CommonData.fieldFloatVector)

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

@@ -4,6 +4,7 @@ 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.index.request.CreateIndexReq;
@@ -26,8 +27,8 @@ public class ListIndexesTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(CommonData.fieldFloatVector)

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

@@ -7,6 +7,7 @@ import com.zilliz.milvustestv2.common.CommonData;
 import com.zilliz.milvustestv2.common.CommonFunction;
 import com.zilliz.milvustestv2.utils.GenerateUtil;
 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;
@@ -29,8 +30,8 @@ public class LoadCollectionTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(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);
     }

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

@@ -7,6 +7,7 @@ import com.zilliz.milvustestv2.common.CommonData;
 import com.zilliz.milvustestv2.common.CommonFunction;
 import com.zilliz.milvustestv2.utils.GenerateUtil;
 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;
@@ -37,12 +38,12 @@ public class LoadPartitionsTest extends BaseTest {
 
     @BeforeClass(alwaysRun = true)
     public void initTestData() {
-        newCollection = CommonFunction.createNewCollection(128, null);
+        newCollection = CommonFunction.createNewCollection(128, null, DataType.FloatVector);
         milvusClientV2.createPartition(CreatePartitionReq.builder()
                 .collectionName(newCollection)
                 .partitionName(CommonData.partitionName)
                 .build());
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(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);
     }

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

@@ -4,6 +4,7 @@ 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.LoadCollectionReq;
@@ -25,8 +26,8 @@ public class ReleaseCollectionTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(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()

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

@@ -7,6 +7,7 @@ import com.zilliz.milvustestv2.common.CommonData;
 import com.zilliz.milvustestv2.common.CommonFunction;
 import com.zilliz.milvustestv2.utils.GenerateUtil;
 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;
@@ -36,12 +37,12 @@ public class ReleasePartitionsTest extends BaseTest {
 
     @BeforeClass(alwaysRun = true)
     public void initTestData() {
-        newCollection = CommonFunction.createNewCollection(128, null);
+        newCollection = CommonFunction.createNewCollection(128, null, DataType.FloatVector);
         milvusClientV2.createPartition(CreatePartitionReq.builder()
                 .collectionName(newCollection)
                 .partitionName(CommonData.partitionName)
                 .build());
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(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);
         milvusClientV2.loadCollection(LoadCollectionReq.builder()

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

@@ -3,6 +3,7 @@ package com.zilliz.milvustestv2.partition;
 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.CreateCollectionReq;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 import io.milvus.v2.service.partition.request.CreatePartitionReq;
@@ -17,16 +18,34 @@ import org.testng.annotations.Test;
  * @Date 2024/2/19 14:33
  */
 public class CreatePartitionTest extends BaseTest {
-    String newCollection;
+    String floatVectorCollection;
+    String sparseFloatVectorCollection;
+    String float16VectorCollection;
+    String bFloat16VectorCollection;
+    String binaryVectorCollection;
 
     @DataProvider(name = "initCollection")
     public Object[][] providerCollection() {
-        newCollection = CommonFunction.createNewCollection(128, null);
-        return new Object[][]{{newCollection}};
+        floatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.FloatVector);
+        sparseFloatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.SparseFloatVector);
+        float16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.Float16Vector);
+        bFloat16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.BFloat16Vector);
+        binaryVectorCollection = CommonFunction.createNewCollection(128, null, DataType.BinaryVector);
+        return new Object[][]{
+                {floatVectorCollection},
+                {sparseFloatVectorCollection},
+                {float16VectorCollection},
+                {bFloat16VectorCollection},
+                {binaryVectorCollection},
+        };
     }
     @AfterClass(alwaysRun = true)
     public void cleanTestData(){
-        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+        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());
 
     }
 

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

@@ -3,6 +3,7 @@ package com.zilliz.milvustestv2.partition;
 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.DropPartitionReq;
@@ -18,29 +19,49 @@ import org.testng.annotations.Test;
  * @Date 2024/2/19 14:34
  */
 public class DropPartitionTest extends BaseTest {
-    String newCollection;
+    String floatVectorCollection;
+    String sparseFloatVectorCollection;
+    String float16VectorCollection;
+    String bFloat16VectorCollection;
+    String binaryVectorCollection;
 
-   @BeforeClass(alwaysRun = true)
-    public void providerCollection() {
-        newCollection = CommonFunction.createNewCollection(128, null);
-        milvusClientV2.createPartition(CreatePartitionReq.builder()
-                .collectionName(newCollection)
-                .partitionName(CommonData.partitionName)
-                .build());
+    @DataProvider(name = "initCollection")
+    public Object[][] providerCollection() {
+        floatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.FloatVector);
+        sparseFloatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.SparseFloatVector);
+        float16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.Float16Vector);
+        bFloat16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.BFloat16Vector);
+        binaryVectorCollection = CommonFunction.createNewCollection(128, null, DataType.BinaryVector);
+        return new Object[][]{
+                {floatVectorCollection},
+                {sparseFloatVectorCollection},
+                {float16VectorCollection},
+                {bFloat16VectorCollection},
+                {binaryVectorCollection},
+        };
     }
+
     @AfterClass(alwaysRun = true)
     public void cleanTestData(){
-        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+        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 = "Drop partition", groups = {"Smoke"})
-    public void dropPartition() {
+    @Test(description = "Drop partition", groups = {"Smoke"},dataProvider = "initCollection")
+    public void dropPartition(String collectionName) {
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(collectionName)
+                .partitionName(CommonData.partitionName)
+                .build());
         milvusClientV2.dropPartition(DropPartitionReq.builder()
-                .collectionName(newCollection)
+                .collectionName(collectionName)
                 .partitionName(CommonData.partitionName)
                 .build());
         Boolean aBoolean = milvusClientV2.hasPartition(HasPartitionReq.builder()
-                .collectionName(newCollection)
+                .collectionName(collectionName)
                 .partitionName(CommonData.partitionName)
                 .build());
         Assert.assertFalse(aBoolean);

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

@@ -3,12 +3,14 @@ package com.zilliz.milvustestv2.partition;
 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.HasPartitionReq;
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
 /**
@@ -16,23 +18,44 @@ import org.testng.annotations.Test;
  * @Date 2024/2/19 14:35
  */
 public class HasPartitionTest extends BaseTest {
-    String newCollection;
-    @BeforeClass(alwaysRun = true)
-    public void providerCollection() {
-        newCollection = CommonFunction.createNewCollection(128, null);
-        milvusClientV2.createPartition(CreatePartitionReq.builder()
-                .collectionName(newCollection)
-                .partitionName(CommonData.partitionName)
-                .build());
+    String floatVectorCollection;
+    String sparseFloatVectorCollection;
+    String float16VectorCollection;
+    String bFloat16VectorCollection;
+    String binaryVectorCollection;
+
+    @DataProvider(name = "initCollection")
+    public Object[][] providerCollection() {
+        floatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.FloatVector);
+        sparseFloatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.SparseFloatVector);
+        float16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.Float16Vector);
+        bFloat16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.BFloat16Vector);
+        binaryVectorCollection = CommonFunction.createNewCollection(128, null, DataType.BinaryVector);
+        return new Object[][]{
+                {floatVectorCollection},
+                {sparseFloatVectorCollection},
+                {float16VectorCollection},
+                {bFloat16VectorCollection},
+                {binaryVectorCollection},
+        };
     }
     @AfterClass(alwaysRun = true)
     public void cleanTestData(){
-        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
+        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 = "Has partition", groups = {"Smoke"})
-    public void hasPartition() {
+    @Test(description = "Has partition", groups = {"Smoke"},dataProvider = "initCollection")
+    public void hasPartition(String collectionName) {
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(collectionName)
+                .partitionName(CommonData.partitionName)
+                .build());
         Boolean aBoolean = milvusClientV2.hasPartition(HasPartitionReq.builder()
-                .collectionName(newCollection)
+                .collectionName(collectionName)
                 .partitionName(CommonData.partitionName)
                 .build());
         Assert.assertTrue(aBoolean);

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

@@ -3,6 +3,7 @@ package com.zilliz.milvustestv2.partition;
 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.HasPartitionReq;
@@ -11,6 +12,7 @@ import org.checkerframework.checker.units.qual.A;
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
 import java.util.List;
@@ -20,23 +22,43 @@ import java.util.List;
  * @Date 2024/2/19 14:35
  */
 public class ListPartitionsTest extends BaseTest {
-    String newCollection;
-    @BeforeClass(alwaysRun = true)
-    public void providerCollection() {
-        newCollection = CommonFunction.createNewCollection(128, null);
-        milvusClientV2.createPartition(CreatePartitionReq.builder()
-                .collectionName(newCollection)
-                .partitionName(CommonData.partitionName)
-                .build());
+    String floatVectorCollection;
+    String sparseFloatVectorCollection;
+    String float16VectorCollection;
+    String bFloat16VectorCollection;
+    String binaryVectorCollection;
+
+    @DataProvider(name = "initCollection")
+    public Object[][] providerCollection() {
+        floatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.FloatVector);
+        sparseFloatVectorCollection = CommonFunction.createNewCollection(128, null, DataType.SparseFloatVector);
+        float16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.Float16Vector);
+        bFloat16VectorCollection = CommonFunction.createNewCollection(128, null, DataType.BFloat16Vector);
+        binaryVectorCollection = CommonFunction.createNewCollection(128, null, DataType.BinaryVector);
+        return new Object[][]{
+                {floatVectorCollection},
+                {sparseFloatVectorCollection},
+                {float16VectorCollection},
+                {bFloat16VectorCollection},
+                {binaryVectorCollection},
+        };
     }
     @AfterClass(alwaysRun = true)
-    public void cleanTestData(){
-        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
-    }
+    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 = "List partitions", groups = {"Smoke"})
-    public void listPartitions() {
-        List<String> strings = milvusClientV2.listPartitions(ListPartitionsReq.builder().collectionName(newCollection).build());
+    }
+    @Test(description = "List partitions", groups = {"Smoke"},dataProvider = "initCollection")
+    public void listPartitions(String collectionName) {
+        milvusClientV2.createPartition(CreatePartitionReq.builder()
+                .collectionName(collectionName)
+                .partitionName(CommonData.partitionName)
+                .build());
+        List<String> strings = milvusClientV2.listPartitions(ListPartitionsReq.builder().collectionName(collectionName).build());
         Assert.assertTrue(strings.contains(CommonData.partitionName));
     }
 

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

@@ -0,0 +1,197 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+import com.google.common.collect.Lists;
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.zilliz.milvustestv2.utils.MathUtil;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.collection.FlushParam;
+import io.milvus.v2.client.ConnectConfig;
+import io.milvus.v2.client.MilvusClientV2;
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.IndexParam;
+import io.milvus.v2.service.collection.request.CreateCollectionReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+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.*;
+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 java.nio.ByteBuffer;
+import java.util.*;
+
+public class BF16SearchIssue {
+    private static int dim = 128;
+    private static String uri="http://10.102.9.177:19530";
+    private static String collectionName = "bf16Collection";
+    private static String pkName = "fieldInt64";
+    private static String vectorName = "fieldBFloat16Vector";
+
+    public static void main(String[] args) {
+        // connect
+        MilvusClientV2 milvusClientV2 = new MilvusClientV2(ConnectConfig.builder()
+                .uri(uri)
+                .token("root:Milvus")
+                .secure(false)
+                .connectTimeoutMs(5000L)
+                .build());
+        // create collection
+        CreateCollectionReq.FieldSchema fieldInt64 = CreateCollectionReq.FieldSchema.builder()
+                .autoID(false)
+                .dataType(io.milvus.v2.common.DataType.Int64)
+                .isPrimaryKey(true)
+                .name(pkName)
+                .build();
+        CreateCollectionReq.FieldSchema fieldVector = CreateCollectionReq.FieldSchema.builder()
+                .dataType(io.milvus.v2.common.DataType.BFloat16Vector)
+                .isPrimaryKey(false)
+                .dimension(dim)
+                .name(vectorName)
+                .build();
+        List<CreateCollectionReq.FieldSchema> fieldSchemaList = new ArrayList<>();
+        fieldSchemaList.add(fieldInt64);
+        fieldSchemaList.add(fieldVector);
+        CreateCollectionReq.CollectionSchema collectionSchema = CreateCollectionReq.CollectionSchema.builder()
+                .fieldSchemaList(fieldSchemaList)
+                .build();
+        CreateCollectionReq createCollectionReq = CreateCollectionReq.builder()
+                .collectionSchema(collectionSchema)
+                .collectionName(collectionName)
+                .enableDynamicField(false)
+                .description("collection desc")
+                .numShards(1)
+                .build();
+        milvusClientV2.createCollection(createCollectionReq);
+        // create index
+        Map<String,Object> extraParamMap=new HashMap<String,Object>(){{
+            put("M", 16);
+            put("efConstruction", 64);
+        }};
+        IndexParam indexParam = IndexParam.builder()
+                .fieldName(vectorName)
+                .indexType(IndexParam.IndexType.HNSW)
+                .metricType(IndexParam.MetricType.L2)
+                .extraParams(extraParamMap)
+                .build();
+
+        milvusClientV2.createIndex(CreateIndexReq.builder()
+                .collectionName(collectionName)
+                .indexParams(Collections.singletonList(indexParam))
+                .build());
+        // load
+        milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(collectionName).build());
+        // insert
+        List<JsonObject> jsonObjects = generateDefaultData(20000, dim);
+        InsertResp insert = milvusClientV2.insert(InsertReq.builder().collectionName(collectionName).data(jsonObjects).build());
+        System.out.println(insert);
+        //query
+        QueryResp query = milvusClientV2.query(QueryReq.builder()
+                .collectionName(collectionName)
+                .ids(Lists.newArrayList(1,10,99)).build());
+        System.out.println("query:"+query.getQueryResults());
+        // search
+        List<BaseVector> data = providerBaseVector(1, dim);
+        for (int i = 0; i < 10; i++) {
+            SearchResp search = milvusClientV2.search(SearchReq.builder()
+                    .collectionName(collectionName)
+                    .outputFields(Lists.newArrayList("*"))
+                    .consistencyLevel(ConsistencyLevel.STRONG)
+                    .data(data)
+                    .topK(10)
+                    .build());
+            System.out.println("first:"+search);
+        }
+        // use v1 flush
+        MilvusServiceClient milvusClientV1 = new MilvusServiceClient(ConnectParam.newBuilder()
+                .withUri(uri).build());
+        milvusClientV1.flush(FlushParam.newBuilder().withCollectionNames(Lists.newArrayList(collectionName)).withSyncFlush(true).build());
+        // search again
+        for (int i = 0; i < 10; i++) {
+            SearchResp search2 = milvusClientV2.search(SearchReq.builder()
+                    .collectionName(collectionName)
+                    .outputFields(Lists.newArrayList("*"))
+                    .consistencyLevel(ConsistencyLevel.STRONG)
+                    .data(data)
+                    .topK(10)
+                    .build());
+            System.out.println("second:" + search2);
+        }
+    }
+
+    public static short floatToBF16(float value) {
+        int bits = Float.floatToIntBits(value);
+        int sign = bits >>> 31;
+        int exp = (bits >>> 23) & 0xFF;
+        int mantissa = bits & 0x7FFFFF;
+
+        if (exp == 0xFF) {
+            // 处理无穷大和 NaN
+            if (mantissa == 0) {
+                return (short) ((sign << 15) | 0x7C00);  // 正负无穷
+            } else {
+                return (short) ((sign << 15) | 0x7C00 | (mantissa >>> 13));  // NaN
+            }
+        }
+
+        exp -= 127;
+        exp += 16;
+        if (exp >= 0x1F) {
+            // 处理溢出情况
+            return (short) ((sign << 15) | 0x7C00);
+        } else if (exp <= 0) {
+            // 处理下溢情况
+            return 0;
+        }
+
+        return (short) ((sign << 15) | (exp << 10) | (mantissa >>> 13));
+    }
+    public static ByteBuffer generateBF16Vector(int dim) {
+        Random ran = new Random();
+        float randomFloat;
+        int byteCount = dim * 2;
+        ByteBuffer vector = ByteBuffer.allocate(byteCount);
+        for (int i = 0; i < dim; ++i) {
+            do {
+                randomFloat = ran.nextFloat();
+            } while (Float.isInfinite(randomFloat));
+            short halfFloatValue = MathUtil.floatToBF16(randomFloat);
+            ByteBuffer buffer = ByteBuffer.allocate(2);
+            buffer.putShort(halfFloatValue);
+            buffer.flip();
+            vector.put(buffer.get(0));
+            vector.put(buffer.get(1));
+        }
+        return vector;
+    }
+
+    public static List<JsonObject> generateDefaultData(long num, int dim) {
+        List<JsonObject> jsonList = new ArrayList<>();
+        Random ran = new Random();
+        Gson gson = new Gson();
+        for (long i = 0; i < num; i++) {
+            JsonObject row = new JsonObject();
+            row.addProperty(pkName, i);
+            row.add(vectorName, gson.toJsonTree(generateBF16Vector(dim).array()));
+            jsonList.add(row);
+        }
+        return jsonList;
+    }
+    public static List<BaseVector> providerBaseVector(int nq, int dim) {
+        List<BaseVector> data = new ArrayList<>();
+        List<ByteBuffer> vectors = new ArrayList<>();
+        for (int n = 0; n < nq; ++n) {
+            vectors.add(generateBF16Vector(dim));
+        }
+        vectors.forEach(x -> {
+            data.add(new BFloat16Vec(x));
+        });
+
+        return data;
+
+    }
+}

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

@@ -4,6 +4,7 @@ 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 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;
@@ -27,8 +28,8 @@ public class DeleteTest extends BaseTest {
     String newCollectionName2;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName1 = CommonFunction.createNewCollection(CommonData.dim, null);
-        newCollectionName2 = CommonFunction.createNewCollection(CommonData.dim, null);
+        newCollectionName1 = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        newCollectionName2 = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(CommonData.fieldFloatVector)
                 .indexType(IndexParam.IndexType.HNSW)

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

@@ -5,6 +5,7 @@ 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 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;
@@ -27,8 +28,8 @@ public class GetTest extends BaseTest {
     String newCollectionName;
     @BeforeClass(alwaysRun = true)
     public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim,DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
         IndexParam indexParam = IndexParam.builder()
                 .fieldName(CommonData.fieldFloatVector)

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

@@ -0,0 +1,113 @@
+package com.zilliz.milvustestv2.vectorOperation;
+
+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 com.zilliz.milvustestv2.params.FieldParam;
+import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.DataType;
+import io.milvus.v2.service.collection.request.DropCollectionReq;
+import io.milvus.v2.service.collection.request.LoadCollectionReq;
+import io.milvus.v2.service.vector.request.AnnSearchReq;
+import io.milvus.v2.service.vector.request.HybridSearchReq;
+import io.milvus.v2.service.vector.request.InsertReq;
+import io.milvus.v2.service.vector.request.ranker.RRFRanker;
+import io.milvus.v2.service.vector.response.InsertResp;
+import io.milvus.v2.service.vector.response.SearchResp;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class HybridSearchTest extends BaseTest {
+
+    @DataProvider(name = "multiVector")
+    public Object[][] providerData() {
+        return new Object[][]{
+                {new ArrayList<FieldParam>() {{
+                    add(FieldParam.builder().fieldName(DataType.FloatVector + "1").dataType(DataType.FloatVector).dim(128).build());
+                    add(FieldParam.builder().fieldName(DataType.FloatVector + "2").dataType(DataType.FloatVector).dim(256).build());
+                    add(FieldParam.builder().fieldName(DataType.FloatVector + "3").dataType(DataType.FloatVector).dim(768).build());
+                }}
+                },
+                {new ArrayList<FieldParam>() {{
+                    add(FieldParam.builder().fieldName(DataType.FloatVector + "2").dataType(DataType.FloatVector).dim(256).build());
+                    add(FieldParam.builder().fieldName(DataType.Float16Vector + "3").dataType(DataType.Float16Vector).dim(768).build());
+                    add(FieldParam.builder().fieldName(DataType.BFloat16Vector + "4").dataType(DataType.BFloat16Vector).dim(128).build());
+                    add(FieldParam.builder().fieldName(DataType.BinaryVector + "5").dataType(DataType.BinaryVector).dim(768).build());
+                }}
+                },
+                {new ArrayList<FieldParam>() {{
+                    add(FieldParam.builder().fieldName(DataType.SparseFloatVector + "1").dataType(DataType.SparseFloatVector).dim(CommonData.dim).build());
+                    add(FieldParam.builder().fieldName(DataType.Float16Vector + "3").dataType(DataType.Float16Vector).dim(768).build());
+                    add(FieldParam.builder().fieldName(DataType.BFloat16Vector + "4").dataType(DataType.BFloat16Vector).dim(128).build());
+                    add(FieldParam.builder().fieldName(DataType.BinaryVector + "5").dataType(DataType.BinaryVector).dim(768).build());
+                }}
+                },
+                {new ArrayList<FieldParam>() {{
+                    add(FieldParam.builder().fieldName(DataType.SparseFloatVector + "1").dataType(DataType.SparseFloatVector).dim(CommonData.dim).build());
+                    add(FieldParam.builder().fieldName(DataType.FloatVector + "2").dataType(DataType.FloatVector).dim(256).build());
+                    add(FieldParam.builder().fieldName(DataType.BFloat16Vector + "4").dataType(DataType.BFloat16Vector).dim(128).build());
+                    add(FieldParam.builder().fieldName(DataType.BinaryVector + "5").dataType(DataType.BinaryVector).dim(768).build());
+                }}
+                },
+                {new ArrayList<FieldParam>() {{
+                    add(FieldParam.builder().fieldName(DataType.SparseFloatVector + "1").dataType(DataType.SparseFloatVector).dim(CommonData.dim).build());
+                    add(FieldParam.builder().fieldName(DataType.FloatVector + "2").dataType(DataType.FloatVector).dim(256).build());
+                    add(FieldParam.builder().fieldName(DataType.Float16Vector + "3").dataType(DataType.Float16Vector).dim(768).build());
+                    add(FieldParam.builder().fieldName(DataType.BinaryVector + "5").dataType(DataType.BinaryVector).dim(768).build());
+                }}
+                },
+                {new ArrayList<FieldParam>() {{
+                    add(FieldParam.builder().fieldName(DataType.SparseFloatVector + "1").dataType(DataType.SparseFloatVector).dim(CommonData.dim).build());
+                    add(FieldParam.builder().fieldName(DataType.FloatVector + "2").dataType(DataType.FloatVector).dim(256).build());
+                    add(FieldParam.builder().fieldName(DataType.Float16Vector + "3").dataType(DataType.Float16Vector).dim(768).build());
+                    add(FieldParam.builder().fieldName(DataType.BFloat16Vector + "4").dataType(DataType.BFloat16Vector).dim(128).build());
+                }}
+                },
+
+
+        };
+    }
+
+
+    @Test(description = "Create Multi vector collection", dataProvider = "multiVector")
+    public void hybridSearchTest(List<FieldParam> fieldParamList) {
+        String s = CommonFunction.genCommonCollection(null, DataType.Int64, false, fieldParamList);
+        System.out.println(s);
+        // insert
+        List<JsonObject> jsonObjects = CommonFunction.genCommonData(s, CommonData.numberEntities);
+        InsertResp insert = milvusClientV2.insert(InsertReq.builder().collectionName(s)
+                .data(jsonObjects).build());
+        // create index
+        CommonFunction.createCommonIndex(s, fieldParamList);
+        milvusClientV2.loadCollection(LoadCollectionReq.builder()
+                .collectionName(s).build());
+        // load
+        milvusClientV2.loadCollection(LoadCollectionReq.builder().collectionName(s).build());
+
+        // hybridSearch
+        List<AnnSearchReq> AnnSearchReqList = new ArrayList<>();
+        for (FieldParam fieldParam : fieldParamList) {
+            AnnSearchReq annSearchReq = CommonFunction.provideAnnSearch(fieldParam, 1, 20, null);
+            AnnSearchReqList.add(annSearchReq);
+        }
+
+        SearchResp searchResp = milvusClientV2.hybridSearch(HybridSearchReq.builder()
+                .collectionName(s)
+                .topK(20)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .searchRequests(AnnSearchReqList)
+                .outFields(Lists.newArrayList("*"))
+                .ranker(new RRFRanker(60))
+                .roundDecimal(-1)
+                .build());
+        Assert.assertEquals(searchResp.getSearchResults().size(), 1);
+        Assert.assertEquals(searchResp.getSearchResults().get(0).size(), 20);
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(s).build());
+    }
+}

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

@@ -4,14 +4,26 @@ 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.client.MilvusClient;
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.collection.FlushParam;
+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.service.collection.response.DescribeCollectionResp;
+import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
 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;
 
+import java.nio.ByteBuffer;
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -19,38 +31,61 @@ import java.util.List;
  * @Date 2024/2/19 17:02
  */
 public class InsertTest extends BaseTest {
-    String newCollectionName;
-    String simpleCollectionName;
+    private String newCollectionName;
+    private String simpleCollectionName;
+
     @BeforeClass(alwaysRun = true)
-    public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
+    public void providerCollection() {
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
         simpleCollectionName = CommonFunction.createSimpleCollection(CommonData.dim, null);
     }
 
     @AfterClass(alwaysRun = true)
-    public void cleanTestData(){
+    public void cleanTestData() {
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(simpleCollectionName).build());
     }
 
-    @Test(description = "insert test",groups = {"Smoke"})
-    public void insert(){
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+    @DataProvider(name = "VectorTypeList")
+    public Object[][] providerVectorType() {
+        return new Object[][]{
+                {DataType.FloatVector},
+                {DataType.BinaryVector},
+                {DataType.Float16Vector},
+                {DataType.BFloat16Vector},
+                {DataType.SparseFloatVector},
+        };
+    }
+
+    @Test(description = "insert test", groups = {"Smoke"})
+    public void insert() {
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         InsertResp insert = milvusClientV2.insert(InsertReq.builder()
                 .data(jsonObjects)
                 .collectionName(newCollectionName)
                 .build());
-        Assert.assertEquals(insert.getInsertCnt(),CommonData.numberEntities);
+        Assert.assertEquals(insert.getInsertCnt(), CommonData.numberEntities);
     }
 
-    @Test(description = "insert simple collection test",groups = {"Smoke"})
-    public void insertIntoSimpleCollection(){
+    @Test(description = "insert simple collection test", groups = {"Smoke"})
+    public void insertIntoSimpleCollection() {
         List<JsonObject> jsonObjects = CommonFunction.generateSimpleData(CommonData.numberEntities, CommonData.dim);
         InsertResp insert = milvusClientV2.insert(InsertReq.builder()
                 .data(jsonObjects)
                 .collectionName(simpleCollectionName)
                 .build());
-        Assert.assertEquals(insert.getInsertCnt(),CommonData.numberEntities);
+        Assert.assertEquals(insert.getInsertCnt(), CommonData.numberEntities);
+    }
+
+    @Test(description = "insert different vector collection test", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void insertIntoDiffVectorCollection(DataType dataType) {
+        String newCollection = CommonFunction.createNewCollection(CommonData.dim, null, dataType);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim, dataType);
+        InsertResp insert = milvusClientV2.insert(InsertReq.builder()
+                .collectionName(newCollection)
+                .data(jsonObjects).build());
+        Assert.assertEquals(insert.getInsertCnt(), CommonData.numberEntities);
+        milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollection).build());
     }
 
 }

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

@@ -3,7 +3,9 @@ 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.utils.DataProviderUtils;
 import io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.DataType;
 import io.milvus.v2.service.collection.request.GetCollectionStatsReq;
 import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
 import io.milvus.v2.service.vector.request.QueryReq;
@@ -55,6 +57,38 @@ public class QueryTest extends BaseTest {
         };
     }
 
+    @DataProvider(name="DiffCollectionWithFilter")
+    public Object[][] providerDiffCollectionWithFilter(){
+        Object[][] vectorType=new Object[][]{
+                {CommonData.defaultBFloat16VectorCollection},
+                {CommonData.defaultBinaryVectorCollection},
+                {CommonData.defaultFloat16VectorCollection},
+                {CommonData.defaultSparseFloatVectorCollection}
+
+        };
+        Object[][] filter=new Object[][]{
+                {CommonData.fieldInt64 + " < 10 ", 10},
+                {CommonData.fieldInt64 + " != 10 ", CommonData.numberEntities - 1},
+                {CommonData.fieldInt64 + " <= 10 ", 11},
+                {"5<" + CommonData.fieldInt64 + " <= 10 ", 5},
+                {CommonData.fieldInt64 + " >= 10 ", CommonData.numberEntities - 10},
+                {CommonData.fieldInt64 + " > 100 ", CommonData.numberEntities - 101},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldBool + " == true", 5},
+                {CommonData.fieldInt64 + " in [1,2,3] ", 3},
+                {CommonData.fieldInt64 + " not in [1,2,3] ", CommonData.numberEntities - 3},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldInt32 + " >5 ", 4},
+                {CommonData.fieldVarchar + " > \"0\" ", CommonData.numberEntities},
+                {CommonData.fieldVarchar + " like \"str%\" ", 0},
+                {CommonData.fieldVarchar + " like \"Str%\" ", CommonData.numberEntities},
+                {CommonData.fieldVarchar + " like \"Str1\" ", 1},
+                {CommonData.fieldInt8 + " > 129 ", 0},
+
+        };
+        Object[][] objects = DataProviderUtils.generateDataSets(vectorType, filter);
+        return objects;
+    }
+
+
     @Test(description = "query", groups = {"Smoke"}, dataProvider = "filterAndExcept")
     public void query(String filter, long expect) {
         QueryResp query = milvusClientV2.query(QueryReq.builder()
@@ -118,4 +152,16 @@ public class QueryTest extends BaseTest {
                 .build());
         Assert.assertEquals(query.getQueryResults().size(), expect);
     }
+
+    @Test(description = "query with different collection", groups = {"Smoke"}, dataProvider = "DiffCollectionWithFilter")
+    public void queryDiffCollection(String collectionName,String filter, long expect) {
+        QueryResp query = milvusClientV2.query(QueryReq.builder()
+                .collectionName(collectionName)
+                .filter(filter)
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .outputFields(Lists.newArrayList("*"))
+                .build());
+        Assert.assertEquals(query.getQueryResults().size(), expect);
+    }
+
 }

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

@@ -1,15 +1,37 @@
 package com.zilliz.milvustestv2.vectorOperation;
 
 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 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.service.collection.response.DescribeCollectionResp;
+import io.milvus.v2.service.collection.response.GetCollectionStatsResp;
+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 org.testng.Assert;
+import org.testng.annotations.BeforeClass;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
@@ -23,10 +45,52 @@ import java.util.Map;
  */
 public class SearchTest extends BaseTest {
     int topK = 10;
+    private MilvusServiceClient milvusServiceClient;
 
     @DataProvider(name = "filterAndExcept")
     public Object[][] providerData() {
         return new Object[][]{
+                {CommonData.fieldInt64 + " != 10 ", topK},
+                {CommonData.fieldInt64 + " < 10 ", topK},
+                {CommonData.fieldVarchar + " like \"%0\" ", topK},
+                {CommonData.fieldInt64 + " <= 10 ", topK},
+                {"5<" + CommonData.fieldInt64 + " <= 10 ", 5},
+                {CommonData.fieldInt64 + " >= 10 ", topK},
+                {CommonData.fieldInt64 + " > 100 ", topK},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldBool + "== true", topK / 2},
+                {CommonData.fieldInt64 + " in [1,2,3] ", 3},
+                {CommonData.fieldInt64 + " not in [1,2,3] ", topK},
+                {CommonData.fieldInt64 + " < 10 and " + CommonData.fieldInt32 + ">5", 4},
+                {CommonData.fieldVarchar + " > \"Str5\" ", topK},
+                {CommonData.fieldVarchar + " like \"str%\" ", 0},
+                {CommonData.fieldVarchar + " like \"Str%\" ", topK},
+                {CommonData.fieldVarchar + " like \"Str1\" ", 1},
+                {CommonData.fieldInt8 + " > 129 ", 0},
+
+        };
+    }
+
+    @DataProvider(name = "VectorTypeList")
+    public Object[][] providerVectorType() {
+        return new Object[][]{
+                {CommonData.defaultFloatVectorCollection, DataType.FloatVector},
+//                {CommonData.defaultBinaryVectorCollection,DataType.BinaryVector},
+                {CommonData.defaultFloat16VectorCollection,DataType.Float16Vector},
+                {CommonData.defaultBFloat16VectorCollection,DataType.BFloat16Vector},
+                {CommonData.defaultSparseFloatVectorCollection,DataType.SparseFloatVector},
+        };
+    }
+
+    @DataProvider(name="VectorTypeWithFilter")
+    public Object[][] providerVectorTypeWithFilter(){
+        Object[][] vectorType=new Object[][]{
+                {DataType.FloatVector},
+                {DataType.BinaryVector},
+                {DataType.Float16Vector},
+                {DataType.BFloat16Vector},
+                {DataType.SparseFloatVector}
+        };
+        Object[][] filter=new Object[][]{
                 {CommonData.fieldVarchar + " like \"%0\" ", topK},
                 {CommonData.fieldInt64 + " < 10 ", topK},
                 {CommonData.fieldInt64 + " != 10 ", topK},
@@ -45,6 +109,8 @@ public class SearchTest extends BaseTest {
                 {CommonData.fieldInt8 + " > 129 ", 0},
 
         };
+        Object[][] objects = DataProviderUtils.generateDataSets(vectorType, filter);
+        return objects;
     }
 
     @DataProvider(name = "searchPartition")
@@ -59,11 +125,9 @@ public class SearchTest extends BaseTest {
         };
     }
 
-    @Test(description = "search", groups = {"Smoke"}, dataProvider = "filterAndExcept")
-    public void search(String filter, int expect) {
-        List<List<Float>> vectors = GenerateUtil.generateFloatVector(CommonData.nq, 3, CommonData.dim);
-        List<BaseVector> data = new ArrayList<>();
-        vectors.forEach((v)->{data.add(new FloatVec(v));});
+    @Test(description = "search float vector collection", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    public void searchFloatVectorCollection(String filter, int expect) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
                 .collectionName(CommonData.defaultFloatVectorCollection)
                 .filter(filter)
@@ -78,11 +142,73 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
+    @Test(description = "search binary vector collection", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    public void searchBinaryVectorCollection(String filter, int expect) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.BinaryVector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(CommonData.defaultBinaryVectorCollection)
+                .filter(filter)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .data(data)
+                .topK(topK)
+                .build());
+        System.out.println(search);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
+    }
+
+    @Test(description = "search bf16 vector collection", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    public void searchBF16VectorCollection(String filter, int expect) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.BFloat16Vector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(CommonData.defaultBFloat16VectorCollection)
+                .filter(filter)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .data(data)
+                .topK(topK)
+                .build());
+        System.out.println(search);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
+    }
+
+    @Test(description = "search float16 vector collection", groups = {"Smoke"}, dataProvider = "filterAndExcept")
+    public void searchFloat16VectorCollection(String filter, int expect) {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.Float16Vector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(CommonData.defaultFloat16VectorCollection)
+                .filter(filter)
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .data(data)
+                .topK(topK)
+                .build());
+        System.out.println(search);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
+    }
+
+    @Test(description = "search Sparse vector collection", groups = {"Smoke"})
+    public void searchSparseVectorCollection() {
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.SparseFloatVector);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(CommonData.defaultSparseFloatVectorCollection)
+                .filter("fieldVarchar like\"%0\"")
+                .outputFields(Lists.newArrayList("*"))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .data(data)
+                .topK(topK)
+                .build());
+        System.out.println(search);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+//        Assert.assertEquals(search.getSearchResults().get(0).size(), topK);
+    }
+
     @Test(description = "default search output params return id and distance", groups = {"Smoke"})
     public void searchWithDefaultOutput() {
-        List<List<Float>> vectors = GenerateUtil.generateFloatVector(CommonData.nq, 3, CommonData.dim);
-        List<BaseVector> data = new ArrayList<>();
-        vectors.forEach((v)->{data.add(new FloatVec(v));});
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
                 .collectionName(CommonData.defaultFloatVectorCollection)
                 .filter(CommonData.fieldInt64 + " < 10 ")
@@ -94,14 +220,12 @@ public class SearchTest extends BaseTest {
         System.out.println(search);
         Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
         Assert.assertEquals(search.getSearchResults().get(0).size(), topK);
-        Assert.assertEquals(search.getSearchResults().get(0).get(0).getEntity().keySet().size(),0);
+        Assert.assertEquals(search.getSearchResults().get(0).get(0).getEntity().keySet().size(), 0);
     }
 
     @Test(description = "search in partition", groups = {"Smoke"}, dataProvider = "searchPartition")
     public void searchInPartition(List<String> partitionName, String filter, int expect) {
-        List<List<Float>> vectors = GenerateUtil.generateFloatVector(CommonData.nq, 3, CommonData.dim);
-        List<BaseVector> data = new ArrayList<>();
-        vectors.forEach((v)->{data.add(new FloatVec(v));});
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
                 .collectionName(CommonData.defaultFloatVectorCollection)
                 .filter(filter)
@@ -119,9 +243,7 @@ public class SearchTest extends BaseTest {
 
     @Test(description = "search by alias", groups = {"Smoke"}, dataProvider = "filterAndExcept")
     public void searchByAlias(String filter, int expect) {
-        List<List<Float>> vectors = GenerateUtil.generateFloatVector(CommonData.nq, 3, CommonData.dim);
-        List<BaseVector> data = new ArrayList<>();
-        vectors.forEach((v)->{data.add(new FloatVec(v));});
+        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, DataType.FloatVector);
         SearchResp search = milvusClientV2.search(SearchReq.builder()
                 .collectionName(CommonData.alias)
                 .filter(filter)
@@ -136,4 +258,20 @@ public class SearchTest extends BaseTest {
         Assert.assertEquals(search.getSearchResults().get(0).size(), expect);
     }
 
+    @Test(description = "search group by field name", groups = {"Smoke"}, dataProvider = "VectorTypeList")
+    public void searchByGroupByField(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)
+                .data(data)
+                .topK(1000)
+                .build());
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        if(vectorType!=DataType.SparseFloatVector) {
+            Assert.assertEquals(search.getSearchResults().get(0).size(), 127);
+        }
+    }
 }

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

@@ -1,19 +1,32 @@
 package com.zilliz.milvustestv2.vectorOperation;
 
+import com.google.common.collect.Lists;
+import com.google.gson.Gson;
 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 io.milvus.v2.common.ConsistencyLevel;
+import io.milvus.v2.common.DataType;
 import io.milvus.v2.service.collection.request.DropCollectionReq;
 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.UpsertReq;
+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 io.milvus.v2.service.vector.response.UpsertResp;
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * @Author yongpeng.li
@@ -21,32 +34,72 @@ import java.util.List;
  */
 public class UpsertTest extends BaseTest {
     String newCollectionName;
+
     @BeforeClass(alwaysRun = true)
-    public void providerCollection(){
-        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null);
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim);
+    public void providerCollection() {
+        newCollectionName = CommonFunction.createNewCollection(CommonData.dim, null, DataType.FloatVector);
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(CommonData.numberEntities, CommonData.dim, DataType.FloatVector);
         milvusClientV2.insert(InsertReq.builder().collectionName(newCollectionName).data(jsonObjects).build());
     }
 
     @AfterClass(alwaysRun = true)
-    public void cleanTestData(){
+    public void cleanTestData() {
         milvusClientV2.dropCollection(DropCollectionReq.builder().collectionName(newCollectionName).build());
     }
 
-    @Test(description = "upsert collection",groups = {"Smoke"})
-    public void upsert(){
-        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(10, CommonData.dim);
+    @DataProvider(name = "DifferentCollection")
+    public Object[][] providerVectorType() {
+        return new Object[][]{
+                {CommonData.defaultFloatVectorCollection, DataType.FloatVector},
+                {CommonData.defaultBinaryVectorCollection, DataType.BinaryVector},
+                {CommonData.defaultFloat16VectorCollection, DataType.Float16Vector},
+                {CommonData.defaultBFloat16VectorCollection, DataType.BFloat16Vector},
+                {CommonData.defaultSparseFloatVectorCollection, DataType.SparseFloatVector},
+        };
+    }
+
+    @Test(description = "upsert collection", groups = {"Smoke"}, dataProvider = "DifferentCollection")
+    public void upsert(String collectionName, DataType vectorType) {
+        List<JsonObject> jsonObjects = CommonFunction.generateDefaultData(1, CommonData.dim, vectorType);
+        for (int i = 1; i < 10; i++) {
+            JsonObject jsonObject0 = jsonObjects.get(0).deepCopy();
+            jsonObject0.addProperty(CommonData.fieldInt64, i);
+            jsonObjects.add(jsonObject0);
+        }
         UpsertResp upsert = milvusClientV2.upsert(UpsertReq.builder()
-                .collectionName(newCollectionName)
+                .collectionName(collectionName)
                 .data(jsonObjects)
+                .partitionName("_default")
+                .build());
+        System.out.println(upsert);
+        Assert.assertEquals(upsert.getUpsertCnt(), 10);
+        // search
+/*        List<BaseVector> data = CommonFunction.providerBaseVector(CommonData.nq, CommonData.dim, vectorType);
+        SearchResp search = milvusClientV2.search(SearchReq.builder()
+                .collectionName(collectionName)
+                .outputFields(Lists.newArrayList(CommonData.fieldInt64, CommonData.fieldInt32))
+                .consistencyLevel(ConsistencyLevel.STRONG)
+                .partitionNames(Lists.newArrayList("_default"))
+                .filter(CommonData.fieldInt32 + " == 0")
+                .data(data)
+                .topK(100)
                 .build());
-        Assert.assertEquals(upsert.getUpsertCnt(),10);
+        Assert.assertEquals(search.getSearchResults().size(), CommonData.nq);
+        Assert.assertEquals(search.getSearchResults().get(0).size(), 10);*/
 
+        // query
+        QueryResp query = milvusClientV2.query(QueryReq.builder()
+                .collectionName(collectionName)
+                .filter(CommonData.fieldInt32 + "== 0")
+                        .partitionNames(Lists.newArrayList(CommonData.defaultPartitionName))
+                .outputFields(Lists.newArrayList(CommonData.fieldInt64, CommonData.fieldInt32))
+                .consistencyLevel(ConsistencyLevel.STRONG).build());
+        Assert.assertEquals(query.getQueryResults().size(),10);
     }
 
-    @Test(description = "upsert collection",groups = {"Smoke"})
-    public void simpleUpsert(){
-        String collection=CommonFunction.createSimpleCollection(128,null);
+    @Test(description = "upsert collection", groups = {"Smoke"})
+    public void simpleUpsert() {
+        String collection = CommonFunction.createSimpleCollection(128, null);
         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);

tests/milvustestv2/src/test/resources/run.properties

@@ -1,3 +1,3 @@
-uri=https://127.0.0.1:19530
+uri=http://10.102.6.30:19530