单元测试调整.

.mvn/wrapper/maven-wrapper.properties

@@ -1 +1 @@
-distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.5.3/apache-maven-3.5.3-bin.zip
+distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.9.4/apache-maven-3.9.4-bin.zip

mybatis-plus-sample-jsonb/src/test/java/com/baomidou/mybatisplus/samples/jsonb/JsonbTest.java

@@ -4,10 +4,12 @@ import com.baomidou.mybatisplus.samples.jsonb.entity.TestContent;
 import com.baomidou.mybatisplus.samples.jsonb.entity.TestData;
 import com.baomidou.mybatisplus.samples.jsonb.mapper.TestDataMapper;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 
+@Disabled
 @SpringBootTest
 public class JsonbTest {
     @Autowired

mybatis-plus-sample-logic-delete/src/test/java/com/baomidou/mybatisplus/samples/logic/LogicDeleteTest.java

@@ -39,37 +39,37 @@ public class LogicDeleteTest {
             commonMapper.insert(common);
             ids.add(common.getId());
         }
-        log.error("------------------------------------------------deleteById--------------------------------------------------------");
+        log.info("------------------------------------------------deleteById--------------------------------------------------------");
         commonMapper.deleteById(ids.remove(0));
-        log.error("------------------------------------------------deleteByMap--------------------------------------------------------");
+        log.info("------------------------------------------------deleteByMap--------------------------------------------------------");
         commonMapper.deleteByMap(Maps.newHashMap("id", ids.remove(0)));
-        log.error("------------------------------------------------delete--------------------------------------------------------");
+        log.info("------------------------------------------------delete--------------------------------------------------------");
         commonMapper.delete(Wrappers.<Common>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------deleteBatchIds--------------------------------------------------------");
+        log.info("------------------------------------------------deleteBatchIds--------------------------------------------------------");
         commonMapper.deleteBatchIds(Arrays.asList(ids.remove(0), ids.remove(0)));
-        log.error("------------------------------------------------updateById--------------------------------------------------------");
+        log.info("------------------------------------------------updateById--------------------------------------------------------");
         commonMapper.updateById(new Common().setId(ids.remove(0)).setName("老王"));
-        log.error("------------------------------------------------update--------------------------------------------------------");
+        log.info("------------------------------------------------update--------------------------------------------------------");
         commonMapper.update(new Common().setName("老王"), Wrappers.<Common>update().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectById--------------------------------------------------------");
+        log.info("------------------------------------------------selectById--------------------------------------------------------");
         commonMapper.selectById(ids.remove(0));
-        log.error("------------------------------------------------selectBatchIds--------------------------------------------------------");
+        log.info("------------------------------------------------selectBatchIds--------------------------------------------------------");
         commonMapper.selectBatchIds(Arrays.asList(ids.remove(0), ids.remove(0)));
-        log.error("------------------------------------------------selectByMap--------------------------------------------------------");
+        log.info("------------------------------------------------selectByMap--------------------------------------------------------");
         commonMapper.selectByMap(Maps.newHashMap("id", ids.remove(0)));
-        log.error("------------------------------------------------selectOne--------------------------------------------------------");
+        log.info("------------------------------------------------selectOne--------------------------------------------------------");
         commonMapper.selectOne(Wrappers.<Common>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectCount--------------------------------------------------------");
+        log.info("------------------------------------------------selectCount--------------------------------------------------------");
         commonMapper.selectCount(Wrappers.<Common>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectList--------------------------------------------------------");
+        log.info("------------------------------------------------selectList--------------------------------------------------------");
         commonMapper.selectList(Wrappers.<Common>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectMaps--------------------------------------------------------");
+        log.info("------------------------------------------------selectMaps--------------------------------------------------------");
         commonMapper.selectMaps(Wrappers.<Common>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectObjs--------------------------------------------------------");
+        log.info("------------------------------------------------selectObjs--------------------------------------------------------");
         commonMapper.selectObjs(Wrappers.<Common>query().select("id").eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectPage--------------------------------------------------------");
+        log.info("------------------------------------------------selectPage--------------------------------------------------------");
         commonMapper.selectPage(new Page<>(), Wrappers.<Common>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectMapsPage--------------------------------------------------------");
+        log.info("------------------------------------------------selectMapsPage--------------------------------------------------------");
         commonMapper.selectMapsPage(new Page<>(), Wrappers.<Common>query().eq("id", ids.remove(0)));
     }
 
@@ -81,37 +81,37 @@ public class LogicDeleteTest {
             null1Mapper.insert(null1);
             ids.add(null1.getId());
         }
-        log.error("------------------------------------------------deleteById--------------------------------------------------------");
+        log.info("------------------------------------------------deleteById--------------------------------------------------------");
         null1Mapper.deleteById(ids.remove(0));
-        log.error("------------------------------------------------deleteByMap--------------------------------------------------------");
+        log.info("------------------------------------------------deleteByMap--------------------------------------------------------");
         null1Mapper.deleteByMap(Maps.newHashMap("id", ids.remove(0)));
-        log.error("------------------------------------------------delete--------------------------------------------------------");
+        log.info("------------------------------------------------delete--------------------------------------------------------");
         null1Mapper.delete(Wrappers.<Null1>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------deleteBatchIds--------------------------------------------------------");
+        log.info("------------------------------------------------deleteBatchIds--------------------------------------------------------");
         null1Mapper.deleteBatchIds(Arrays.asList(ids.remove(0), ids.remove(0)));
-        log.error("------------------------------------------------updateById--------------------------------------------------------");
+        log.info("------------------------------------------------updateById--------------------------------------------------------");
         null1Mapper.updateById(new Null1().setId(ids.remove(0)).setName("老王"));
-        log.error("------------------------------------------------update--------------------------------------------------------");
+        log.info("------------------------------------------------update--------------------------------------------------------");
         null1Mapper.update(new Null1().setName("老王"), Wrappers.<Null1>update().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectById--------------------------------------------------------");
+        log.info("------------------------------------------------selectById--------------------------------------------------------");
         null1Mapper.selectById(ids.remove(0));
-        log.error("------------------------------------------------selectBatchIds--------------------------------------------------------");
+        log.info("------------------------------------------------selectBatchIds--------------------------------------------------------");
         null1Mapper.selectBatchIds(Arrays.asList(ids.remove(0), ids.remove(0)));
-        log.error("------------------------------------------------selectByMap--------------------------------------------------------");
+        log.info("------------------------------------------------selectByMap--------------------------------------------------------");
         null1Mapper.selectByMap(Maps.newHashMap("id", ids.remove(0)));
-        log.error("------------------------------------------------selectOne--------------------------------------------------------");
+        log.info("------------------------------------------------selectOne--------------------------------------------------------");
         null1Mapper.selectOne(Wrappers.<Null1>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectCount--------------------------------------------------------");
+        log.info("------------------------------------------------selectCount--------------------------------------------------------");
         null1Mapper.selectCount(Wrappers.<Null1>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectList--------------------------------------------------------");
+        log.info("------------------------------------------------selectList--------------------------------------------------------");
         null1Mapper.selectList(Wrappers.<Null1>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectMaps--------------------------------------------------------");
+        log.info("------------------------------------------------selectMaps--------------------------------------------------------");
         null1Mapper.selectMaps(Wrappers.<Null1>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectObjs--------------------------------------------------------");
+        log.info("------------------------------------------------selectObjs--------------------------------------------------------");
         null1Mapper.selectObjs(Wrappers.<Null1>query().select("id").eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectPage--------------------------------------------------------");
+        log.info("------------------------------------------------selectPage--------------------------------------------------------");
         null1Mapper.selectPage(new Page<>(), Wrappers.<Null1>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectMapsPage--------------------------------------------------------");
+        log.info("------------------------------------------------selectMapsPage--------------------------------------------------------");
         null1Mapper.selectMapsPage(new Page<>(), Wrappers.<Null1>query().eq("id", ids.remove(0)));
     }
 
@@ -123,37 +123,37 @@ public class LogicDeleteTest {
             null2Mapper.insert(null2);
             ids.add(null2.getId());
         }
-        log.error("------------------------------------------------deleteById--------------------------------------------------------");
+        log.info("------------------------------------------------deleteById--------------------------------------------------------");
         null2Mapper.deleteById(ids.remove(0));
-        log.error("------------------------------------------------deleteByMap--------------------------------------------------------");
+        log.info("------------------------------------------------deleteByMap--------------------------------------------------------");
         null2Mapper.deleteByMap(Maps.newHashMap("id", ids.remove(0)));
-        log.error("------------------------------------------------delete--------------------------------------------------------");
+        log.info("------------------------------------------------delete--------------------------------------------------------");
         null2Mapper.delete(Wrappers.<Null2>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------deleteBatchIds--------------------------------------------------------");
+        log.info("------------------------------------------------deleteBatchIds--------------------------------------------------------");
         null2Mapper.deleteBatchIds(Arrays.asList(ids.remove(0), ids.remove(0)));
-        log.error("------------------------------------------------updateById--------------------------------------------------------");
+        log.info("------------------------------------------------updateById--------------------------------------------------------");
         null2Mapper.updateById(new Null2().setId(ids.remove(0)).setName("老王"));
-        log.error("------------------------------------------------update--------------------------------------------------------");
+        log.info("------------------------------------------------update--------------------------------------------------------");
         null2Mapper.update(new Null2().setName("老王"), Wrappers.<Null2>update().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectById--------------------------------------------------------");
+        log.info("------------------------------------------------selectById--------------------------------------------------------");
         null2Mapper.selectById(ids.remove(0));
-        log.error("------------------------------------------------selectBatchIds--------------------------------------------------------");
+        log.info("------------------------------------------------selectBatchIds--------------------------------------------------------");
         null2Mapper.selectBatchIds(Arrays.asList(ids.remove(0), ids.remove(0)));
-        log.error("------------------------------------------------selectByMap--------------------------------------------------------");
+        log.info("------------------------------------------------selectByMap--------------------------------------------------------");
         null2Mapper.selectByMap(Maps.newHashMap("id", ids.remove(0)));
-        log.error("------------------------------------------------selectOne--------------------------------------------------------");
+        log.info("------------------------------------------------selectOne--------------------------------------------------------");
         null2Mapper.selectOne(Wrappers.<Null2>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectCount--------------------------------------------------------");
+        log.info("------------------------------------------------selectCount--------------------------------------------------------");
         null2Mapper.selectCount(Wrappers.<Null2>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectList--------------------------------------------------------");
+        log.info("------------------------------------------------selectList--------------------------------------------------------");
         null2Mapper.selectList(Wrappers.<Null2>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectMaps--------------------------------------------------------");
+        log.info("------------------------------------------------selectMaps--------------------------------------------------------");
         null2Mapper.selectMaps(Wrappers.<Null2>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectObjs--------------------------------------------------------");
+        log.info("------------------------------------------------selectObjs--------------------------------------------------------");
         null2Mapper.selectObjs(Wrappers.<Null2>query().select("id").eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectPage--------------------------------------------------------");
+        log.info("------------------------------------------------selectPage--------------------------------------------------------");
         null2Mapper.selectPage(new Page<>(), Wrappers.<Null2>query().eq("id", ids.remove(0)));
-        log.error("------------------------------------------------selectMapsPage--------------------------------------------------------");
+        log.info("------------------------------------------------selectMapsPage--------------------------------------------------------");
         null2Mapper.selectMapsPage(new Page<>(), Wrappers.<Null2>query().eq("id", ids.remove(0)));
     }
 }

mybatis-plus-sample-mysql/src/test/java/com/baomidou/mybatisplus/samples/mysql/MysqlTest.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.samples.mysql.mapper.TestDataMapper;
 import mybatis.mate.ddl.DdlScript;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -17,6 +18,7 @@ import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+@Disabled
 @SpringBootTest
 class MysqlTest {
     @Autowired

mybatis-plus-sample-pagination/src/test/java/com/baomidou/mybatisplus/samples/pagination/PaginationTest.java

@@ -47,18 +47,18 @@ class PaginationTest {
 
     @Test
     void tests1() {
-        log.error("----------------------------------baseMapper 自带分页-------------------------------------------------------");
+        log.info("----------------------------------baseMapper 自带分页-------------------------------------------------------");
         Page<User> page = new Page<>(1, 5);
         page.addOrder(OrderItem.asc("age"));
         Page<User> userIPage = mapper.selectPage(page, Wrappers.<User>lambdaQuery().eq(User::getAge, 20).like(User::getName, "Jack"));
         assertThat(page).isSameAs(userIPage);
-        log.error("总条数 -------------> {}", userIPage.getTotal());
-        log.error("当前页数 -------------> {}", userIPage.getCurrent());
-        log.error("当前每页显示数 -------------> {}", userIPage.getSize());
+        log.info("总条数 -------------> {}", userIPage.getTotal());
+        log.info("当前页数 -------------> {}", userIPage.getCurrent());
+        log.info("当前每页显示数 -------------> {}", userIPage.getSize());
         List<User> records = userIPage.getRecords();
         assertThat(records).isNotEmpty();
 
-        log.error("----------------------------------json 正反序列化-------------------------------------------------------");
+        log.info("----------------------------------json 正反序列化-------------------------------------------------------");
         String json = JSON.toJSONString(page);
         log.info("json ----------> {}", json);
         Page<User> page1 = JSON.parseObject(json, new TypeReference<Page<User>>() {
@@ -67,14 +67,14 @@ class PaginationTest {
         assertThat(records1).isNotEmpty();
         assertThat(records1.get(0).getClass()).isEqualTo(User.class);
 
-        log.error("----------------------------------自定义 XML 分页-------------------------------------------------------");
+        log.info("----------------------------------自定义 XML 分页-------------------------------------------------------");
         MyPage<User> myPage = new MyPage<User>(1, 5).setSelectInt(20).setSelectStr("Jack");
         ParamSome paramSome = new ParamSome(20, "Jack");
         MyPage<User> userMyPage = mapper.mySelectPage(myPage, paramSome);
         assertThat(myPage).isSameAs(userMyPage);
-        log.error("总条数 -------------> {}", userMyPage.getTotal());
-        log.error("当前页数 -------------> {}", userMyPage.getCurrent());
-        log.error("当前每页显示数 -------------> {}", userMyPage.getSize());
+        log.info("总条数 -------------> {}", userMyPage.getTotal());
+        log.info("当前页数 -------------> {}", userMyPage.getCurrent());
+        log.info("当前每页显示数 -------------> {}", userMyPage.getSize());
     }
 
     @Test

mybatis-plus-sample-sql-injector/src/test/java/com/baomidou/samples/injector/InjectorTest.java

@@ -25,14 +25,14 @@ public class InjectorTest {
 
     @Test
     public void test() {
-        log.error("--------------------------------------insert-------------------------------------------------------");
+        log.info("--------------------------------------insert-------------------------------------------------------");
         List<Long> ids = Lists.newArrayList();
         for (int i = 0; i < 2; i++) {
             Student student = new Student("小明" + i + "号", i);
             studentMapper.insert(student);
             ids.add(student.getId());
         }
-        log.error("--------------------------------------insertBatchSomeColumn-------------------------------------------------------");
+        log.info("--------------------------------------insertBatchSomeColumn-------------------------------------------------------");
         List<Student> ss = Lists.newArrayList();
         for (int i = 2; i < 20; i++) {
             Student student = new Student("小明" + i + "号", i);
@@ -44,7 +44,7 @@ public class InjectorTest {
         Student select = studentMapper.select("select * from student where id = " + ids.get(0));
         System.out.println(select);
 
-        log.error("--------------------------------------deleteAll-------------------------------------------------------");
+        log.info("--------------------------------------deleteAll-------------------------------------------------------");
         studentMapper.deleteAll();
     }
 }

pom.xml

@@ -55,7 +55,8 @@
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>17</java.version>
         <mybatisplus.version>3.5.4-SNAPSHOT</mybatisplus.version>
-        <skipTests>true</skipTests>
+        <skipTests>false</skipTests>
+        <argLine>-Dfile.encoding=UTF-8</argLine>
     </properties>
 
     <dependencyManagement>