modify log4j to log4j2 and add testcase (#365)

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

tests/milvustest/allure-results/environment.properties

@@ -1,3 +1,3 @@
-milvus.url=10.101.158.153
+milvus.url=10.100.31.102
 milvus.version=2.1.0
 milvus-jdk-java.version=2.1.0

tests/milvustest/pom.xml

@@ -21,12 +21,24 @@
         <!--TestNg Aullre Report Use-->
         <aspectj.version>1.9.2</aspectj.version>
         <allure.version>2.13.2</allure.version>
+        <jackson.version>2.10.1</jackson.version>
+        <log4j2.version>2.17.2</log4j2.version>
         <xmlFileName>testng.xml</xmlFileName>
     </properties>
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter</artifactId>
+            <exclusions>
+                <exclusion>
+                    <artifactId>logback-classic</artifactId>
+                    <groupId>ch.qos.logback</groupId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.logging.log4j</groupId>
+                    <artifactId>log4j-to-slf4j</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
 
         <dependency>
@@ -62,17 +74,17 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>2.10.1</version>
+            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.10.1</version>
+            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>2.10.1</version>
+            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>io.milvus</groupId>
@@ -92,9 +104,24 @@
             <version>${aspectj.version}</version>
         </dependency>
         <dependency>
-            <groupId>log4j</groupId>
-            <artifactId>log4j</artifactId>
-            <version>1.2.17</version>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.7.36</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-slf4j-impl</artifactId>
+            <version>2.17.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <version>${log4j2.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>${log4j2.version}</version>
         </dependency>
         <dependency>
             <groupId>io.minio</groupId>

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

@@ -17,7 +17,8 @@ import io.milvus.param.credential.DeleteCredentialParam;
 import io.milvus.param.dml.InsertParam;
 import io.milvus.param.index.CreateIndexParam;
 import io.milvus.param.partition.CreatePartitionParam;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
 import org.springframework.test.context.web.WebAppConfiguration;
@@ -37,8 +38,8 @@ import java.util.List;
 @SpringBootTest(classes = MilvustestApplication.class)
 @WebAppConfiguration
 public class BaseTest extends AbstractTestNGSpringContextTests {
-  public static Logger logger = Logger.getLogger(BaseTest.class);
-  public static SoftAssert softAssert = new SoftAssert();
+  public static final Logger logger= LoggerFactory.getLogger(BaseTest.class);
+  public static final SoftAssert softAssert = new SoftAssert();
   public static final MilvusServiceClient milvusClient =
       new MilvusServiceClient(
           ConnectParam.newBuilder()
@@ -60,7 +61,7 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
 
   @BeforeSuite(alwaysRun = true)
   public void initCollection() {
-    System.out.println(
+    logger.info(
         "**************************************************BeforeSuit**********************");
     initEvn();
     // check collection is existed
@@ -87,7 +88,7 @@ public class BaseTest extends AbstractTestNGSpringContextTests {
 
   @AfterSuite(alwaysRun = true)
   public void cleanTestData() {
-    System.out.println(
+    logger.info(
         "**************************************************AfterSuit**********************");
     logger.info("drop Default Collection");
     milvusClient.dropCollection(

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

@@ -19,7 +19,7 @@ public class CommonData {
 
   public static String defaultBinaryIndex = "BinaryVectorIndex";
   public static String defaultExtraParam =
-      "{\"nlist\":1024,\"M\":16,\"efConstruction\":64, \"PQM\":16,\"nbits\":8}";
+          "{\"nlist\":128}";
   public static String defaultUserName = "UserNameAT";
   public static String defaultPassword = "Password123AT";
   public static String defaultBulkLoadPath = "./src/test/java/resources/temp/";

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

@@ -12,7 +12,8 @@ import io.milvus.param.collection.CreateCollectionParam;
 import io.milvus.param.collection.FieldType;
 import io.milvus.param.dml.InsertParam;
 import io.milvus.param.partition.CreatePartitionParam;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
 
 import java.nio.ByteBuffer;
@@ -22,7 +23,7 @@ import java.util.Random;
 
 @Component
 public class CommonFunction {
-  static Logger logger = Logger.getLogger(CommonFunction.class);
+  public static Logger logger = LoggerFactory.getLogger(CommonFunction.class);
 
   // int PK, float vector collection
   public static String createNewCollection() {
@@ -429,7 +430,7 @@ public class CommonFunction {
         extraParm = "{\"M\":16,\"efConstruction\":64}";
         break;
       default:
-        extraParm = "";
+        extraParm = "{\"nlist\":128}";
         break;
     }
     return extraParm;

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

@@ -1,12 +1,14 @@
 package com.zilliz.milvustest.service;
 
-import org.apache.log4j.Logger;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.testng.ITestContext;
 import org.testng.ITestResult;
 import org.testng.TestListenerAdapter;
 
-public class ComstumerListener extends TestListenerAdapter {
-  Logger logger = Logger.getLogger(ComstumerListener.class);
+public class CustomerListener extends TestListenerAdapter {
+  private static final Logger logger = LoggerFactory.getLogger(CustomerListener.class);
   /**
    * 开始
    *
@@ -15,8 +17,7 @@ public class ComstumerListener extends TestListenerAdapter {
   @Override
   public void onStart(ITestContext iTestContext) {
     super.onStart(iTestContext);
-    logger.info(
-        String.format("====================[%s]测试开始====================", iTestContext.getName()));
+    logger.info("===================={}测试开始====================", iTestContext.getName());
   }
 
   /**
@@ -27,7 +28,7 @@ public class ComstumerListener extends TestListenerAdapter {
   @Override
   public void onTestStart(ITestResult iTestResult) {
     super.onTestStart(iTestResult);
-    logger.info(String.format("========%s测试开始========", iTestResult.getName()));
+    logger.info("========{}测试开始========", iTestResult.getName());
   }
 
   /**
@@ -38,7 +39,7 @@ public class ComstumerListener extends TestListenerAdapter {
   @Override
   public void onTestSuccess(ITestResult iTestResult) {
     super.onTestSuccess(iTestResult);
-    logger.info(String.format("========%s测试通过========", iTestResult.getName()));
+    logger.info("========{}测试通过========", iTestResult.getName());
   }
 
   /**
@@ -49,12 +50,8 @@ public class ComstumerListener extends TestListenerAdapter {
   @Override
   public void onTestFailure(ITestResult iTestResult) {
     super.onTestFailure(iTestResult);
-    logger.error(
-        String.format(
-            "========%s测试失败,失败原因如下：\n%s========",
-            iTestResult.getName(), iTestResult.getThrowable()));
+    logger.error("========{}测试失败,失败原因如下：\n{}========", iTestResult.getName(), iTestResult.getThrowable());
 
-    /** 出现异常进行截图操作，这里得要自己去实现 */
   }
 
   /**
@@ -65,7 +62,7 @@ public class ComstumerListener extends TestListenerAdapter {
   @Override
   public void onTestSkipped(ITestResult iTestResult) {
     super.onTestSkipped(iTestResult);
-    logger.info(String.format("========%s跳过测试========", iTestResult.getName()));
+    logger.info("========{}跳过测试========", iTestResult.getName());
   }
 
   /**
@@ -76,7 +73,6 @@ public class ComstumerListener extends TestListenerAdapter {
   @Override
   public void onFinish(ITestContext iTestContext) {
     super.onFinish(iTestContext);
-    logger.info(
-        String.format("====================%s测试结束====================", iTestContext.getName()));
+    logger.info("===================={}测试结束====================", iTestContext.getName());
   }
 }

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

@@ -1,6 +1,8 @@
 package com.zilliz.milvustest.service;
 
-import org.apache.log4j.Logger;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.testng.ITestContext;
 import org.testng.ITestListener;
 import org.testng.ITestResult;
@@ -10,7 +12,7 @@ import java.text.SimpleDateFormat;
 import java.util.Date;
 
 public class LogRecord implements ITestListener {
-  Logger logger = Logger.getLogger(LogRecord.class);
+  Logger logger = LoggerFactory.getLogger(LogRecord.class);
 
   @Override
   public void onTestStart(ITestResult result) {

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

@@ -7,7 +7,8 @@ import io.minio.MakeBucketArgs;
 import io.minio.MinioClient;
 import io.minio.UploadObjectArgs;
 import io.minio.errors.MinioException;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.*;
 import java.security.InvalidKeyException;
@@ -15,7 +16,7 @@ import java.security.NoSuchAlgorithmException;
 import java.util.*;
 
 public class FileUtils {
-  public static Logger logger = Logger.getLogger(FileUtils.class);
+  public static Logger logger = LoggerFactory.getLogger(FileUtils.class);
 
   // generate Json File
   public static boolean createFile(

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

@@ -1,6 +1,10 @@
 package com.zilliz.milvustest.util;
 
-import org.apache.log4j.Logger;
+
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.BufferedInputStream;
 import java.io.FileInputStream;
@@ -10,7 +14,7 @@ import java.util.Iterator;
 import java.util.Properties;
 
 public class PropertyFilesUtil {
-  static Logger logger = Logger.getLogger(PropertyFilesUtil.class);
+  static Logger logger = LoggerFactory.getLogger(PropertyFilesUtil.class);
 
   public static HashMap<String, String> readPropertyFile(String propertyFileName) {
     HashMap<String, String> hashMap = new HashMap<>();

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

@@ -1 +1,2 @@
-
+#log
+logging.config=classpath:log4j2.xml

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

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

tests/milvustest/src/main/resources/log4j2.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration status="info" monitorInterval="5">
+
+    <properties>
+        <property name="LOG_HOME">./logs</property>
+    </properties>
+
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
+        </Console>
+        <File name="file" fileName="${LOG_HOME}/running.log">
+            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
+        </File>
+        <RandomAccessFile name="accessFile" fileName="${LOG_HOME}/AccessLog.log">
+            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
+        </RandomAccessFile>
+        <RollingFile name="rollingFile" fileName="${LOG_HOME}/rollingLog.log"
+                     filePattern="${LOG_HOME}/$${date:yyyy-MM-dd}/myrollog-%d{yyyy-MM-dd}-%i.log">
+            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" />
+            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %msg%n" />
+            <Policies>
+                <OnStartupTriggeringPolicy />
+                <SizeBasedTriggeringPolicy size="2MB" />
+                <TimeBasedTriggeringPolicy />
+            </Policies>
+            <DefaultRolloverStrategy max="10" />
+        </RollingFile>
+    </Appenders>
+
+    <Loggers>
+        <Root level="info">
+             <AppenderRef ref="Console" />
+            <AppenderRef ref="file" />
+            <AppenderRef ref="rollingFile" />
+            <!--<AppenderRef ref="accessFile" />-->
+        </Root>
+    </Loggers>
+</configuration>

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

@@ -18,6 +18,10 @@ import org.testng.annotations.AfterClass;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.*;
+
 @Epic("Collection")
 @Feature("CreateCollection")
 public class CreateCollectionTest extends BaseTest {
@@ -25,13 +29,14 @@ public class CreateCollectionTest extends BaseTest {
   public String binaryVectorCollection;
 
   public String stringPKCollection;
+  public String maxFieldCollection;
 
   @DataProvider(name = "collectionByDataProvider")
   public Object[][] provideCollectionName() {
     return new String[][] {{"collection_" + MathUtil.getRandomString(10)}};
   }
 
-  @AfterClass(description = "delete test datas after CreateCollectionTest",alwaysRun=true)
+  @AfterClass(description = "delete test datas after CreateCollectionTest", alwaysRun = true)
   public void deleteTestData() {
     if (commonCollection != null) {
       milvusClient.dropCollection(
@@ -45,6 +50,10 @@ public class CreateCollectionTest extends BaseTest {
       milvusClient.dropCollection(
           DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
     }
+    if (maxFieldCollection != null) {
+      milvusClient.dropCollection(
+          DropCollectionParam.newBuilder().withCollectionName(maxFieldCollection).build());
+    }
   }
 
   @DataProvider(name = "dataTypeProvider")
@@ -77,7 +86,10 @@ public class CreateCollectionTest extends BaseTest {
   }
 
   @Severity(SeverityLevel.BLOCKER)
-  @Test(description = "Create collection success", dataProvider = "collectionByDataProvider",groups = {"Smoke"})
+  @Test(
+      description = "Create collection success",
+      dataProvider = "collectionByDataProvider",
+      groups = {"Smoke"})
   public void createCollectionSuccess(String collectionName) {
     commonCollection = collectionName;
     FieldType fieldType1 =
@@ -304,4 +316,170 @@ public class CreateCollectionTest extends BaseTest {
     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");
+  }
+
+  @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)
+                .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;
+        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)
+                                .addFieldType(fieldType1)
+                                .addFieldType(fieldType2)
+                                .addFieldType(fieldType3)
+                                .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);
+      }
+    });
+  }
+
 }

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

@@ -4,6 +4,7 @@ import com.zilliz.milvustest.common.BaseTest;
 import com.zilliz.milvustest.common.CommonData;
 import com.zilliz.milvustest.common.CommonFunction;
 import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.exception.ParamException;
 import io.milvus.grpc.DescribeCollectionResponse;
 import io.milvus.grpc.QueryResults;
 import io.milvus.grpc.SearchResults;
@@ -122,4 +123,14 @@ public class DropCollectionTest extends BaseTest {
     Assert.assertEquals(describeCollectionResponseR.getStatus().intValue(), 1);
     Assert.assertTrue(describeCollectionResponseR.getException().getMessage().contains("can't find collection"));
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "drop empty collection",expectedExceptions = ParamException.class)
+  public void dropEmptyCollection() {
+    DropCollectionParam build =
+            DropCollectionParam.newBuilder().withCollectionName("").build();
+    R<RpcStatus> rpcStatusR = milvusClient.dropCollection(build);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+
+  }
 }

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

@@ -1,12 +1,15 @@
 package com.zilliz.milvustest.collection;
 
 import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
 import com.zilliz.milvustest.common.CommonFunction;
 import io.milvus.param.R;
 import io.milvus.param.RpcStatus;
 import io.milvus.param.collection.DropCollectionParam;
 import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.collection.ReleaseCollectionParam;
+import io.milvus.param.partition.LoadPartitionsParam;
+import io.milvus.param.partition.ReleasePartitionsParam;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -17,6 +20,8 @@ import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.Arrays;
+
 @Epic("Collection")
 @Feature("LoadCollection")
 public class LoadCollectionTest extends BaseTest {
@@ -66,4 +71,55 @@ public class LoadCollectionTest extends BaseTest {
     Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
     Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Load partition after load collection")
+  public void loadPartitionAfterLoadCollection() {
+    LoadCollectionParam loadCollectionParam =
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build();
+    milvusClient.loadCollection(loadCollectionParam);
+    R<RpcStatus> rpcStatusR =
+        milvusClient.loadPartitions(
+            LoadPartitionsParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+                .build());
+
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 5);
+    Assert.assertTrue(
+        rpcStatusR
+            .getException()
+            .getMessage()
+            .contains("has been loaded into QueryNode, please release collection firstly"));
+    milvusClient.releaseCollection(
+        ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Load collection after load partition")
+  public void loadCollectionAfterLoadPartition() {
+    milvusClient.loadPartitions(
+        LoadPartitionsParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+            .build());
+    LoadCollectionParam loadCollectionParam =
+        LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build();
+    R<RpcStatus> rpcStatusR = milvusClient.loadCollection(loadCollectionParam);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 5);
+    Assert.assertTrue(
+        rpcStatusR
+            .getException()
+            .getMessage()
+            .contains("has been loaded into QueryNode, please release partitions firstly"));
+    milvusClient.releasePartitions(
+        ReleasePartitionsParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+            .build());
+  }
+
+
 }

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

@@ -12,6 +12,7 @@ import io.milvus.param.collection.LoadCollectionParam;
 import io.milvus.param.collection.ReleaseCollectionParam;
 import io.milvus.param.dml.QueryParam;
 import io.milvus.param.dml.SearchParam;
+import io.milvus.param.partition.LoadPartitionsParam;
 import io.qameta.allure.Epic;
 import io.qameta.allure.Feature;
 import io.qameta.allure.Severity;
@@ -82,4 +83,21 @@ public class ReleaseCollectionTest extends BaseTest {
     Assert.assertTrue(
             searchResultsR.getException().getMessage().contains("checkIfLoaded failed when search"));
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "release collection after load partition")
+  public void releaseCollectionAfterLoadPartition() {
+    milvusClient.loadPartitions(
+        LoadPartitionsParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
+            .build());
+    R<RpcStatus> rpcStatusR =
+        milvusClient.releaseCollection(
+            ReleaseCollectionParam.newBuilder()
+                .withCollectionName(CommonData.defaultCollection)
+                .build());
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+  }
 }

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

@@ -342,4 +342,100 @@ public class CreateIndexTest extends BaseTest {
             DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
   }
 
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "repeat create index")
+  public void repeatCreateIndex() {
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFieldName(CommonData.defaultVectorField)
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(MetricType.IP)
+                            .withIndexType(IndexType.HNSW)
+                            .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                            .withSyncMode(Boolean.TRUE)
+                            .withSyncWaitingTimeout(30L)
+                            .withSyncWaitingInterval(500L)
+                            .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(rpcStatusR.getException().getMessage().contains("index already exists"));
+
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Create multiple index with different fields")
+  public void createMultiIndexWithDiffFields() {
+    String stringPKCollection = CommonFunction.createStringPKCollection();
+    milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(stringPKCollection)
+                    .withFieldName("book_content")
+                    .withIndexName("indexName1")
+                    .withMetricType(MetricType.IP)
+                    .withIndexType(IndexType.HNSW)
+                    .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                    .withSyncMode(Boolean.TRUE)
+                    .withSyncWaitingTimeout(30L)
+                    .withSyncWaitingInterval(500L)
+                    .build());
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(stringPKCollection)
+                            .withFieldName("book_name")
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(MetricType.IP)
+                            .withIndexType(IndexType.HNSW)
+                            .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                            .withSyncMode(Boolean.TRUE)
+                            .withSyncWaitingTimeout(30L)
+                            .withSyncWaitingInterval(500L)
+                            .build());
+    System.out.println("Create index" + rpcStatusR);
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 0);
+    Assert.assertEquals(rpcStatusR.getData().getMsg(), "Success");
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Create multiple index with same index name")
+  public void createMultiIndexWithSameIndexName() {
+    String stringPKCollection = CommonFunction.createStringPKCollection();
+    milvusClient.createIndex(
+            CreateIndexParam.newBuilder()
+                    .withCollectionName(stringPKCollection)
+                    .withFieldName("book_content")
+                    .withIndexName(CommonData.defaultIndex)
+                    .withMetricType(MetricType.IP)
+                    .withIndexType(IndexType.HNSW)
+                    .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                    .withSyncMode(Boolean.TRUE)
+                    .withSyncWaitingTimeout(30L)
+                    .withSyncWaitingInterval(500L)
+                    .build());
+    R<RpcStatus> rpcStatusR =
+            milvusClient.createIndex(
+                    CreateIndexParam.newBuilder()
+                            .withCollectionName(stringPKCollection)
+                            .withFieldName("book_name")
+                            .withIndexName(CommonData.defaultIndex)
+                            .withMetricType(MetricType.IP)
+                            .withIndexType(IndexType.HNSW)
+                            .withExtraParam(CommonFunction.provideExtraParam(IndexType.HNSW))
+                            .withSyncMode(Boolean.TRUE)
+                            .withSyncWaitingTimeout(30L)
+                            .withSyncWaitingInterval(500L)
+                            .build());
+    System.out.println("Create index" + rpcStatusR);
+    softAssert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    softAssert.assertTrue(rpcStatusR.getException().getMessage().contains("index already exists"));
+    milvusClient.dropCollection(
+            DropCollectionParam.newBuilder().withCollectionName(stringPKCollection).build());
+    softAssert.assertAll();
+  }
+
+
 }

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

@@ -4,6 +4,7 @@ import com.zilliz.milvustest.common.BaseTest;
 import com.zilliz.milvustest.common.CommonData;
 import com.zilliz.milvustest.common.CommonFunction;
 import com.zilliz.milvustest.util.MathUtil;
+import io.milvus.exception.ParamException;
 import io.milvus.grpc.DataType;
 import io.milvus.grpc.MutationResult;
 import io.milvus.param.R;
@@ -254,4 +255,87 @@ public class InsertTest extends BaseTest {
     milvusClient.dropCollection(DropCollectionParam.newBuilder().withCollectionName(collectionName).build());
   }
 
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert field inconsistent dimension")
+  public void insertVectorFieldInconsistentDim() {
+    Random ran = new Random();
+    List<Long> book_id_array = new ArrayList<>();
+    List<Long> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      book_id_array.add( i);
+      word_count_array.add(i+10000);
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 127; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", book_id_array));
+    fields.add(new InsertParam.Field("word_count", word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, book_intro_array));
+
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("The field: VectorFieldAutoTest is not provided"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert field inconsistent number",expectedExceptions = ParamException.class)
+  public void insertVectorFieldInconsistentNumber() {
+    Random ran = new Random();
+    List<Long> book_id_array = new ArrayList<>();
+    List<Long> word_count_array = new ArrayList<>();
+    List<List<Float>> book_intro_array = new ArrayList<>();
+    for (long i = 0L; i < 100; ++i) {
+      book_id_array.add( i);
+      word_count_array.add(i+10000);
+
+    }
+    for (int i = 0; i < 90; i++) {
+      List<Float> vector = new ArrayList<>();
+      for (int k = 0; k < 128; ++k) {
+        vector.add(ran.nextFloat());
+      }
+      book_intro_array.add(vector);
+    }
+    List<InsertParam.Field> fields = new ArrayList<>();
+    fields.add(new InsertParam.Field("book_id", book_id_array));
+    fields.add(new InsertParam.Field("word_count", word_count_array));
+    fields.add(
+            new InsertParam.Field(
+                    CommonData.defaultVectorField, book_intro_array));
+
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName(CommonData.defaultCollection)
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), -5);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("Row count of fields must be equal"));
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Insert into nonexistent collection")
+  public void insertIntoNonexistentCollection() {
+    List<InsertParam.Field> fields = CommonFunction.generateData(10);
+    R<MutationResult> mutationResultR =
+            milvusClient.insert(
+                    InsertParam.newBuilder()
+                            .withCollectionName("NonexistentCollection")
+                            .withFields(fields)
+                            .build());
+    Assert.assertEquals(mutationResultR.getStatus().intValue(), 1);
+    Assert.assertTrue(mutationResultR.getException().getMessage().contains("can't find collection"));
+  }
+
 }

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

@@ -1,12 +1,15 @@
 package com.zilliz.milvustest.partition;
 
 import com.zilliz.milvustest.common.BaseTest;
+import com.zilliz.milvustest.common.CommonData;
 import com.zilliz.milvustest.common.CommonFunction;
 import com.zilliz.milvustest.util.MathUtil;
 import io.milvus.grpc.QueryResults;
 import io.milvus.param.R;
 import io.milvus.param.RpcStatus;
 import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.collection.ReleaseCollectionParam;
 import io.milvus.param.dml.QueryParam;
 import io.milvus.param.partition.CreatePartitionParam;
 import io.milvus.param.partition.DropPartitionParam;
@@ -111,4 +114,26 @@ public class ReleasePartitionsTest extends BaseTest {
             .getMessage()
             .contains("partitionID of partitionName:NonexistentPartition can not be find"));
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "release partition after load collection")
+  public void releasePartitionAfterLoadCollection() {
+    LoadCollectionParam loadCollectionParam =
+            LoadCollectionParam.newBuilder().withCollectionName(CommonData.defaultCollection).build();
+    milvusClient.loadCollection(loadCollectionParam);
+    R<RpcStatus> rpcStatusR = milvusClient.releasePartitions(ReleasePartitionsParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .withPartitionNames(Arrays.asList(CommonData.defaultPartition)).build());
+
+    Assert.assertEquals(rpcStatusR.getStatus().intValue(), 1);
+    Assert.assertTrue(
+            rpcStatusR
+                    .getException()
+                    .getMessage()
+                    .contains("releasing some partitions after load collection is not supported"));
+    milvusClient.releaseCollection(
+            ReleaseCollectionParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .build());
+  }
 }

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

@@ -974,4 +974,44 @@ public class QueryAsyncTest extends BaseTest {
     milvusClient.dropCollection(
             DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
   }
+
+  @Test(description = "int PK and float vector query without pk field")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryAsyncWithoutPKField() throws ExecutionException, InterruptedException {
+    String SEARCH_PARAM = "word_count in [10002,10004,10006,10008]";
+    List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper(CommonData.defaultVectorField).getDim(), 128);
+  }
+
+  @Test(description = "int PK and float vector query with invalid expression")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryAsyncWithInvalidExpression() throws ExecutionException, InterruptedException {
+    String SEARCH_PARAM = "word_count = 10002 ";
+    List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<QueryResults>> rListenableFuture = milvusClient.queryAsync(queryParam);
+    R<QueryResults> queryResultsR = rListenableFuture.get();
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(queryResultsR.getException().getMessage().contains("cannot parse expression"));
+
+  }
 }

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

@@ -951,4 +951,42 @@ public class QueryTest extends BaseTest {
     milvusClient.dropCollection(
         DropCollectionParam.newBuilder().withCollectionName(newCollection).build());
   }
+
+  @Test(description = "int PK and float vector query without pk field")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryWithoutPKField() {
+    String SEARCH_PARAM = "word_count in [10002,10004,10006,10008]";
+    List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    QueryResultsWrapper wrapperQuery = new QueryResultsWrapper(queryResultsR.getData());
+    System.out.println(wrapperQuery.getFieldWrapper("book_id").getFieldData());
+    System.out.println(wrapperQuery.getFieldWrapper("word_count").getFieldData());
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 0);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("word_count").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper("book_id").getFieldData().size(), 4);
+    Assert.assertEquals(wrapperQuery.getFieldWrapper(CommonData.defaultVectorField).getDim(), 128);
+  }
+
+  @Test(description = "int PK and float vector query with invalid expression")
+  @Severity(SeverityLevel.NORMAL)
+  public void queryWithInvalidExpression() {
+    String SEARCH_PARAM = "word_count = 10002 ";
+    List<String> outFields = Arrays.asList("book_id", "word_count", CommonData.defaultVectorField);
+    QueryParam queryParam =
+            QueryParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withOutFields(outFields)
+                    .withExpr(SEARCH_PARAM)
+                    .build();
+    R<QueryResults> queryResultsR = milvusClient.query(queryParam);
+    Assert.assertEquals(queryResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(queryResultsR.getException().getMessage().contains("cannot parse expression"));
+
+  }
 }

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

@@ -1789,4 +1789,59 @@ public class SearchAsyncTest extends BaseTest {
       Assert.fail(e.getMessage());
     }
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Search without load")
+  public void searchAsyncWithoutLoad() throws ExecutionException, InterruptedException {
+    milvusClient.releaseCollection(ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withMetricType(MetricType.L2)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    R<SearchResults> searchResultsR = rListenableFuture.get();
+    Assert.assertEquals(searchResultsR.getStatus().intValue(),1);
+    Assert.assertTrue(searchResultsR.getException().getMessage().contains("checkIfLoaded failed when search"));
+    milvusClient.loadCollection(LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "string PK Search with error expressions")
+  public void stringPKSearchAsyncWithErrorExpressions() throws ExecutionException, InterruptedException {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withMetricType(MetricType.L2)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .withExpr( "  book_name = a")
+                    .build();
+    ListenableFuture<R<SearchResults>> rListenableFuture = milvusClient.searchAsync(searchParam);
+    R<SearchResults> searchResultsR = rListenableFuture.get();
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(searchResultsR.getException().getMessage().contains("cannot parse expression"));
+
+  }
 }

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

@@ -426,114 +426,6 @@ public class SearchTest extends BaseTest {
     System.out.println(searchResultsR.getData().getResults());
   }
 
-  /*  @Severity(SeverityLevel.CRITICAL)
-  @Test(description = "int PK and float vector search by partition")
-  public void intPKAndFloatVectorSearchByPartition() {
-    Integer SEARCH_K = 2; // TopK
-    String SEARCH_PARAM = "{\"nprobe\":10}";
-    List<String> search_output_fields = Arrays.asList("book_id");
-    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
-    SearchParam searchParam =
-        SearchParam.newBuilder()
-            .withCollectionName(CommonData.defaultCollection)
-            .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
-            .withMetricType(MetricType.L2)
-            .withOutFields(search_output_fields)
-            .withTopK(SEARCH_K)
-            .withVectors(search_vectors)
-            .withVectorFieldName(CommonData.defaultVectorField)
-            .withParams(SEARCH_PARAM)
-            .build();
-    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
-    Assert.assertEquals(
-        searchResultsR.getData().getResults().getIds().getIntId().getDataCount(), 2);
-    System.out.println(searchResultsR.getData().getResults());
-  }
-
-  @Severity(SeverityLevel.CRITICAL)
-  @Test(description = "int PK and binary vector search by partition")
-  public void intPKAndBinaryVectorSearchByPartition() {
-    Integer SEARCH_K = 2; // TopK
-    String SEARCH_PARAM = "{\"nprobe\":10}";
-    List<String> search_output_fields = Arrays.asList("book_id");
-    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
-    SearchParam searchParam =
-            SearchParam.newBuilder()
-                    .withCollectionName(CommonData.defaultBinaryCollection)
-                    .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
-                    .withMetricType(MetricType.JACCARD)
-                    .withOutFields(search_output_fields)
-                    .withTopK(SEARCH_K)
-                    .withVectors(search_vectors)
-                    .withVectorFieldName(CommonData.defaultBinaryVectorField)
-                    .withParams(SEARCH_PARAM)
-                    .build();
-    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
-    Assert.assertEquals(
-            searchResultsR.getData().getResults().getIds().getIntId().getDataCount(), 2);
-    System.out.println(searchResultsR.getData().getResults());
-  }
-
-  @Severity(SeverityLevel.CRITICAL)
-  @Test(description = "String PK and float vector search by partition")
-  public void stringPKAndFloatVectorSearchByPartition() {
-    Integer SEARCH_K = 2; // TopK
-    String SEARCH_PARAM = "{\"nprobe\":10}";
-    List<String> search_output_fields = Arrays.asList("book_name");
-    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
-    SearchParam searchParam =
-            SearchParam.newBuilder()
-                    .withCollectionName(CommonData.defaultStringPKCollection)
-                    .withPartitionNames(Arrays.asList(CommonData.defaultStringPKPartition))
-                    .withMetricType(MetricType.L2)
-                    .withOutFields(search_output_fields)
-                    .withTopK(SEARCH_K)
-                    .withVectors(search_vectors)
-                    .withVectorFieldName(CommonData.defaultVectorField)
-                    .withParams(SEARCH_PARAM)
-                    .build();
-    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
-    SearchResultsWrapper searchResultsWrapper =
-            new SearchResultsWrapper(searchResultsR.getData().getResults());
-    Assert.assertEquals(
-            searchResultsWrapper.getFieldData("book_name",0).size(), 2);
-    System.out.println(searchResultsR.getData().getResults());
-  }
-
-  @Severity(SeverityLevel.CRITICAL)
-  @Test(description = "string PK and binary vector search by partition")
-  public void stringPKAndBinaryVectorSearchByPartition() {
-    Integer SEARCH_K = 2; // TopK
-    String SEARCH_PARAM = "{\"nprobe\":10}";
-    List<String> search_output_fields = Arrays.asList("book_name");
-    List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
-    SearchParam searchParam =
-            SearchParam.newBuilder()
-                    .withCollectionName(CommonData.defaultStringPKBinaryCollection)
-                    .withPartitionNames(Arrays.asList(CommonData.defaultStringPKBinaryPartition))
-                    .withMetricType(MetricType.JACCARD)
-                    .withOutFields(search_output_fields)
-                    .withTopK(SEARCH_K)
-                    .withVectors(search_vectors)
-                    .withVectorFieldName(CommonData.defaultBinaryVectorField)
-                    .withParams(SEARCH_PARAM)
-                    .build();
-    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-    Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-    Assert.assertEquals(searchResultsR.getData().getResults().getTopK(), 2);
-    SearchResultsWrapper searchResultsWrapper =
-            new SearchResultsWrapper(searchResultsR.getData().getResults());
-    Assert.assertEquals(
-            searchResultsWrapper.getFieldData("book_name",0).size(), 2);
-    System.out.println(searchResultsR.getData().getResults());
-  }*/
-
   @Severity(SeverityLevel.NORMAL)
   @Test(description = "search in nonexistent  partition")
   public void searchInNonexistentPartition() {
@@ -1402,309 +1294,6 @@ public class SearchTest extends BaseTest {
     System.out.println(searchResultsR.getData().getResults());
   }
 
-  /* @Severity(SeverityLevel.NORMAL)
-    @Test(description = "int Pk and float vector search in partition after insert  entity")
-    public void intPKAndFloatVectorSearchByPartitionAfterInsert() throws InterruptedException {
-      // insert first
-      List<Long> book_id_array =
-          new ArrayList<Long>() {
-            {
-              add(9999L);
-            }
-          };
-      List<Long> word_count_array =
-          new ArrayList<Long>() {
-            {
-              add(19999L);
-            }
-          };
-      List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
-      List<List<Float>> book_intro_array =
-          new ArrayList<List<Float>>() {
-            {
-              add(fs);
-            }
-          };
-      List<InsertParam.Field> fields = new ArrayList<>();
-      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
-      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
-      fields.add(
-          new InsertParam.Field(
-              CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
-      milvusClient.insert(
-          InsertParam.newBuilder()
-              .withCollectionName(CommonData.defaultCollection)
-              .withPartitionName(CommonData.defaultPartition)
-              .withFields(fields)
-              .build());
-      Thread.sleep(2000);
-
-      Integer SEARCH_K = 1; // TopK
-      String SEARCH_PARAM = "{\"nprobe\":10}";
-      List<String> search_output_fields = Arrays.asList("book_id","word_count");
-      SearchParam searchParam =
-          SearchParam.newBuilder()
-              .withCollectionName(CommonData.defaultCollection)
-              .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
-              .withMetricType(MetricType.L2)
-              .withOutFields(search_output_fields)
-              .withTopK(SEARCH_K)
-              .withVectors(book_intro_array)
-              .withVectorFieldName(CommonData.defaultVectorField)
-              .withParams(SEARCH_PARAM)
-              .build();
-      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-      SearchResultsWrapper searchResultsWrapper =
-              new SearchResultsWrapper(searchResultsR.getData().getResults());
-      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
-      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id",0).get(0),9999L);
-      System.out.println(searchResultsR.getData().getResults());
-    }
-
-    @Severity(SeverityLevel.NORMAL)
-    @Test(description = "int PK and binary vector search after insert the entity")
-    public void intPKAndBinaryVectorSearchByPartitionAfterInsertNewEntity() throws InterruptedException {
-      // insert entity first
-      List<Long> book_id_array =
-              new ArrayList<Long>() {
-                {
-                  add(9999L);
-                }
-              };
-      List<Long> word_count_array =
-              new ArrayList<Long>() {
-                {
-                  add(19999L);
-                }
-              };
-      List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
-
-      List<InsertParam.Field> fields = new ArrayList<>();
-      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
-      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
-      fields.add(
-              new InsertParam.Field(
-                      CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
-      milvusClient.insert(
-              InsertParam.newBuilder()
-                      .withCollectionName(CommonData.defaultBinaryCollection)
-                      .withPartitionName(CommonData.defaultBinaryPartition)
-                      .withFields(fields)
-                      .build());
-      Thread.sleep(2000);
-      // search
-      Integer SEARCH_K = 1; // TopK
-      String SEARCH_PARAM = "{\"nprobe\":10}";
-      List<String> search_output_fields = Arrays.asList("book_id","word_count");
-
-      SearchParam searchParam =
-              SearchParam.newBuilder()
-                      .withCollectionName(CommonData.defaultBinaryCollection)
-                      .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
-                      .withMetricType(MetricType.JACCARD)
-                      .withOutFields(search_output_fields)
-                      .withTopK(SEARCH_K)
-                      .withVectors(book_intro_array)
-                      .withVectorFieldName(CommonData.defaultBinaryVectorField)
-                      .withParams(SEARCH_PARAM)
-                      .build();
-      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-      SearchResultsWrapper searchResultsWrapper =
-              new SearchResultsWrapper(searchResultsR.getData().getResults());
-      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
-      Assert.assertEquals(searchResultsWrapper.getFieldData("book_id",0).get(0),9999L);
-      System.out.println(searchResultsR.getData().getResults());
-    }
-
-    @Severity(SeverityLevel.NORMAL)
-    @Test(description = "int PK and float vector search after update the entity")
-    public void intPKAndFloatVectorSearchByPartitionAfterUpdateEntity() throws InterruptedException {
-      Random random = new Random();
-      int id = random.nextInt(2000);
-      // update entity first
-      List<Long> book_id_array =
-              new ArrayList<Long>() {
-                {
-                  add((long) id);
-                }
-              };
-      List<Long> word_count_array =
-              new ArrayList<Long>() {
-                {
-                  add(19999L);
-                }
-              };
-      List<Float> fs = Arrays.asList(MathUtil.generateFloat(128));
-      List<List<Float>> book_intro_array =
-              new ArrayList<List<Float>>() {
-                {
-                  add(fs);
-                }
-              };
-      List<InsertParam.Field> fields = new ArrayList<>();
-      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
-      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
-      fields.add(
-              new InsertParam.Field(
-                      CommonData.defaultVectorField, DataType.FloatVector, book_intro_array));
-      milvusClient.insert(
-              InsertParam.newBuilder()
-                      .withCollectionName(CommonData.defaultCollection)
-                      .withPartitionName(CommonData.defaultPartition)
-                      .withFields(fields)
-                      .build());
-      Thread.sleep(2000);
-      // search
-      Integer SEARCH_K = 1; // TopK
-      String SEARCH_PARAM = "{\"nprobe\":10}";
-      List<String> search_output_fields = Arrays.asList("book_id","word_count");
-
-      SearchParam searchParam =
-              SearchParam.newBuilder()
-                      .withCollectionName(CommonData.defaultCollection)
-                      .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
-                      .withMetricType(MetricType.L2)
-                      .withOutFields(search_output_fields)
-                      .withTopK(SEARCH_K)
-                      .withVectors(book_intro_array)
-                      .withVectorFieldName(CommonData.defaultVectorField)
-                      .withParams(SEARCH_PARAM)
-                      .build();
-      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-      SearchResultsWrapper searchResultsWrapper =
-              new SearchResultsWrapper(searchResultsR.getData().getResults());
-      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
-      System.out.println(searchResultsR.getData().getResults());
-    }
-
-    @Severity(SeverityLevel.NORMAL)
-    @Test(description = "int PK and binary vector search after update the entity")
-    public void intPKAndBinaryVectorSearchByPartitionAfterUpdateEntity() throws InterruptedException {
-      Random random = new Random();
-      int id = random.nextInt(2000);
-      // update entity first
-      List<Long> book_id_array =
-              new ArrayList<Long>() {
-                {
-                  add((long) id);
-                }
-              };
-      List<Long> word_count_array =
-              new ArrayList<Long>() {
-                {
-                  add(19999L);
-                }
-              };
-      List<ByteBuffer> book_intro_array = CommonFunction.generateBinaryVectors(1, 128);
-
-      List<InsertParam.Field> fields = new ArrayList<>();
-      fields.add(new InsertParam.Field("book_id", DataType.Int64, book_id_array));
-      fields.add(new InsertParam.Field("word_count", DataType.Int64, word_count_array));
-      fields.add(
-              new InsertParam.Field(
-                      CommonData.defaultBinaryVectorField, DataType.BinaryVector, book_intro_array));
-      milvusClient.insert(
-              InsertParam.newBuilder()
-                      .withCollectionName(CommonData.defaultBinaryCollection)
-                      .withPartitionName(CommonData.defaultBinaryPartition)
-                      .withFields(fields)
-                      .build());
-      Thread.sleep(2000);
-      // search
-      Integer SEARCH_K = 1; // TopK
-      String SEARCH_PARAM = "{\"nprobe\":10}";
-      List<String> search_output_fields = Arrays.asList("book_id","word_count");
-
-      SearchParam searchParam =
-              SearchParam.newBuilder()
-                      .withCollectionName(CommonData.defaultBinaryCollection)
-                      .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
-                      .withMetricType(MetricType.JACCARD)
-                      .withOutFields(search_output_fields)
-                      .withTopK(SEARCH_K)
-                      .withVectors(book_intro_array)
-                      .withVectorFieldName(CommonData.defaultBinaryVectorField)
-                      .withParams(SEARCH_PARAM)
-                      .build();
-      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-      SearchResultsWrapper searchResultsWrapper =
-              new SearchResultsWrapper(searchResultsR.getData().getResults());
-      Assert.assertEquals(searchResultsWrapper.getFieldData("word_count",0).get(0),19999L);
-      System.out.println(searchResultsR.getData().getResults());
-    }
-
-    @Severity(SeverityLevel.NORMAL)
-    @Test(description = "int PK and float vector search after delete data")
-    public void intPKAndFloatVectorSearchByPartitionAfterDelete() throws InterruptedException {
-      R<MutationResult> mutationResultR =
-              milvusClient.delete(
-                      DeleteParam.newBuilder()
-                              .withCollectionName(CommonData.defaultCollection)
-                              .withPartitionName(CommonData.defaultPartition)
-                              .withExpr("book_id in [1,2,3]")
-                              .build());
-      Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
-      Thread.sleep(2000);
-      Integer SEARCH_K = 2; // TopK
-      String SEARCH_PARAM = "{\"nprobe\":10}";
-      List<String> search_output_fields = Arrays.asList("book_id");
-      List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
-      SearchParam searchParam =
-              SearchParam.newBuilder()
-                      .withCollectionName(CommonData.defaultCollection)
-                      .withPartitionNames(Arrays.asList(CommonData.defaultPartition))
-                      .withMetricType(MetricType.L2)
-                      .withOutFields(search_output_fields)
-                      .withTopK(SEARCH_K)
-                      .withVectors(search_vectors)
-                      .withVectorFieldName(CommonData.defaultVectorField)
-                      .withParams(SEARCH_PARAM)
-                      .withExpr(" book_id in [1,2,3] ")
-                      .build();
-      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-      System.out.println(searchResultsR.getData().getResults());
-      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-      Assert.assertEquals(searchResultsR.getData().getResults().getFieldsDataCount(), 0);
-    }
-
-    @Severity(SeverityLevel.NORMAL)
-    @Test(description = "int PK and binary vector search after delete data")
-    public void intPKAndBinaryVectorSearchByPartitionAfterDelete() throws InterruptedException {
-      R<MutationResult> mutationResultR =
-              milvusClient.delete(
-                      DeleteParam.newBuilder()
-                              .withCollectionName(CommonData.defaultBinaryCollection)
-                              .withPartitionName(CommonData.defaultBinaryPartition)
-                              .withExpr("book_id in [1,2,3]")
-                              .build());
-      Assert.assertEquals(mutationResultR.getData().getDeleteCnt(), 3L);
-      Thread.sleep(2000);
-      Integer SEARCH_K = 2; // TopK
-      String SEARCH_PARAM = "{\"nprobe\":10}";
-      List<String> search_output_fields = Arrays.asList("book_id");
-      List<ByteBuffer> search_vectors = CommonFunction.generateBinaryVectors(1, 128);
-      SearchParam searchParam =
-              SearchParam.newBuilder()
-                      .withCollectionName(CommonData.defaultBinaryCollection)
-                      .withPartitionNames(Arrays.asList(CommonData.defaultBinaryPartition))
-                      .withMetricType(MetricType.JACCARD)
-                      .withOutFields(search_output_fields)
-                      .withTopK(SEARCH_K)
-                      .withVectors(search_vectors)
-                      .withVectorFieldName(CommonData.defaultBinaryVectorField)
-                      .withParams(SEARCH_PARAM)
-                      .withExpr(" book_id in [1,2,3] ")
-                      .build();
-      R<SearchResults> searchResultsR = milvusClient.search(searchParam);
-      System.out.println(searchResultsR.getData().getResults());
-      Assert.assertEquals(searchResultsR.getStatus().intValue(), 0);
-      Assert.assertEquals(searchResultsR.getData().getResults().getFieldsDataCount(), 0);
-    }
-  */
   @Severity(SeverityLevel.CRITICAL)
   @Test(description = "int PK and float vector search by alias")
   public void intPKAndFloatVectorSearchByAlias() {
@@ -2023,4 +1612,57 @@ public class SearchTest extends BaseTest {
     Assert.assertTrue(searchResultsWrapper.getFieldData("book_name", 0).size()>=1);
     System.out.println(searchResultsR.getData().getResults());
   }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "Search without load")
+  public void searchWithoutLoad(){
+    milvusClient.releaseCollection(ReleaseCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_id");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultCollection)
+                    .withMetricType(MetricType.L2)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(),1);
+    Assert.assertTrue(searchResultsR.getException().getMessage().contains("checkIfLoaded failed when search"));
+    milvusClient.loadCollection(LoadCollectionParam.newBuilder()
+            .withCollectionName(CommonData.defaultCollection)
+            .build());
+  }
+
+  @Severity(SeverityLevel.NORMAL)
+  @Test(description = "string PK Search with error expressions")
+  public void stringPKSearchWithErrorExpressions() {
+    Integer SEARCH_K = 2; // TopK
+    String SEARCH_PARAM = "{\"nprobe\":10}";
+    List<String> search_output_fields = Arrays.asList("book_name");
+    List<List<Float>> search_vectors = Arrays.asList(Arrays.asList(MathUtil.generateFloat(128)));
+
+    SearchParam searchParam =
+            SearchParam.newBuilder()
+                    .withCollectionName(CommonData.defaultStringPKCollection)
+                    .withMetricType(MetricType.L2)
+                    .withOutFields(search_output_fields)
+                    .withTopK(SEARCH_K)
+                    .withVectors(search_vectors)
+                    .withVectorFieldName(CommonData.defaultVectorField)
+                    .withParams(SEARCH_PARAM)
+                    .withExpr( "  book_name = a")
+                    .build();
+    R<SearchResults> searchResultsR = milvusClient.search(searchParam);
+    Assert.assertEquals(searchResultsR.getStatus().intValue(), 1);
+    Assert.assertTrue(searchResultsR.getException().getMessage().contains("cannot parse expression"));
+
+  }
 }

tests/milvustest/testng.xml

@@ -11,4 +11,7 @@
             <package name="com.zilliz.milvustest.*"/>
         </packages>
     </test>
+    <listeners>
+        <listener class-name="com.zilliz.milvustest.service.CustomerListener"></listener>
+    </listeners>
 </suite>

tests/milvustest/testngAll.xml

@@ -98,6 +98,6 @@
          </classes>
      </test>-->
     <listeners>
-        <listener class-name="com.zilliz.milvustest.service.ComstumerListener"/>
+        <listener class-name="com.zilliz.milvustest.service.CustomerListener"/>
     </listeners>
 </suite>