zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(Mutable): 补充针对基础数据类型的工厂方法与接口默认方法

Browse Source
This commit is contained in:
huangchengxing
2023-04-26 21:48:30 +08:00
parent 73ddd17f7a
commit 69e013cd98
13 changed files with 671 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/BaseMutableTest.java Normal file
View File

@@ -0,0 +1,129 @@
package org.dromara.hutool.core.lang.mutable;
import org.dromara.hutool.core.text.StrValidator;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.Objects;
/**
* base test for {@link Mutable} implementations.
*
* @author huangchengxing
*/
abstract class BaseMutableTest<V, M extends Mutable<V>> {
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
abstract V getValue1();
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
abstract V getValue2();
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
abstract M getMutable(V value);
@Test
void testOf() {
Assertions.assertInstanceOf(MutableBool.class, Mutable.of(true));
Assertions.assertInstanceOf(MutableByte.class, Mutable.of((byte) 1));
Assertions.assertInstanceOf(MutableDouble.class, Mutable.of(1.0D));
Assertions.assertInstanceOf(MutableFloat.class, Mutable.of(1.0F));
Assertions.assertInstanceOf(MutableInt.class, Mutable.of(1));
Assertions.assertInstanceOf(MutableLong.class, Mutable.of(1L));
Assertions.assertInstanceOf(MutableObj.class, Mutable.of(new Object()));
Assertions.assertInstanceOf(MutableShort.class, Mutable.of((short) 1));
}
@Test
void testGet() {
Mutable<V> mutableObj = getMutable(getValue1());
V value = mutableObj.get();
Assertions.assertEquals(getValue1(), value);
}
@Test
void testSet() {
Mutable<V> mutableObj = getMutable(getValue2());
mutableObj.set(getValue2());
V value = mutableObj.get();
Assertions.assertEquals(getValue2(), value);
}
@Test
void testTo() {
Mutable<V> mutableObj = getMutable(getValue1());
String value = mutableObj.to(String::valueOf);
Assertions.assertEquals(String.valueOf(getValue1()), value);
}
@Test
void testToOpt() {
Mutable<V> mutableObj = getMutable(getValue1());
V value = mutableObj.toOpt().get();
Assertions.assertEquals(getValue1(), value);
}
@Test
void testMap() {
Mutable<V> mutableObj = getMutable(getValue1());
V value = mutableObj.map(v -> getValue2()).get();
Assertions.assertEquals(getValue2(), value);
}
@Test
void testTest() {
Mutable<V> mutableObj = getMutable(getValue1());
Assertions.assertTrue(mutableObj.test(Objects::nonNull));
}
@Test
void testPeek() {
Mutable<V> m1 = getMutable(getValue1());
Mutable<V> m2 = getMutable(getValue2());
m1.peek(m2::set);
Assertions.assertEquals(getValue1(), m2.get());
}
@Test
void testHashCode() {
V value = getValue1();
Mutable<V> mutableObj = new MutableObj<>(value);
Assertions.assertEquals(value.hashCode(), mutableObj.hashCode());
mutableObj.set(null);
Assertions.assertEquals(0, mutableObj.hashCode());
}
@Test
void testEquals() {
V value = getValue1();
Mutable<V> mutableObj = new MutableObj<>(value);
Assertions.assertNotEquals(value, mutableObj);
Assertions.assertEquals(mutableObj, mutableObj);
Assertions.assertEquals(mutableObj, new MutableObj<>(value));
Assertions.assertNotEquals(mutableObj, new MutableObj<>(null));
Assertions.assertNotEquals(mutableObj, null);
Assertions.assertNotEquals(mutableObj, value);
}
@Test
void testToString() {
V value = getValue1();
Mutable<V> mutableObj = new MutableObj<>(value);
Assertions.assertEquals(value.toString(), mutableObj.toString());
mutableObj.set(null);
Assertions.assertEquals(StrValidator.NULL, mutableObj.toString());
}
}

40
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableBoolTest.java Normal file
View File

@@ -0,0 +1,40 @@
package org.dromara.hutool.core.lang.mutable;
/**
* test for {@link MutableBool}
*
* @author huangchengxing
*/
public class MutableBoolTest extends BaseMutableTest<Boolean, MutableBool> {
/**
* 创建一个值
*
* @return 值
*/
@Override
Boolean getValue1() {
return Boolean.TRUE;
}
/**
* 创建一个值
*
* @return 值
*/
@Override
Boolean getValue2() {
return Boolean.FALSE;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableBool getMutable(Boolean value) {
return new MutableBool(value);
}
}

38
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableByteTest.java Normal file
View File

@@ -0,0 +1,38 @@
package org.dromara.hutool.core.lang.mutable;
/**
* @author huangchengxing
*/
public class MutableByteTest extends BaseMutableTest<Number, MutableByte> {
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue1() {
return Byte.MAX_VALUE;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue2() {
return Byte.MIN_VALUE;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableByte getMutable(Number value) {
return new MutableByte(value);
}
}

38
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableDoubleTest.java Normal file
View File

@@ -0,0 +1,38 @@
package org.dromara.hutool.core.lang.mutable;
/**
* @author huangchengxing
*/
public class MutableDoubleTest extends BaseMutableTest<Number, MutableDouble> {
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue1() {
return Double.MAX_VALUE;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue2() {
return Double.MAX_VALUE;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableDouble getMutable(Number value) {
return new MutableDouble(value);
}
}

45
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableEntryTest.java Normal file
View File

@@ -0,0 +1,45 @@
package org.dromara.hutool.core.lang.mutable;
import org.dromara.hutool.core.map.MapUtil;
import java.util.Map;
/**
* @author huangchengxing
*/
public class MutableEntryTest extends BaseMutableTest<Map.Entry<String, String>, MutableEntry<String, String>> {
private static final Map.Entry<String, String> ENTRY1 = MapUtil.entry("key1", "value1");
private static final Map.Entry<String, String> ENTRY2 = MapUtil.entry("key2", "value2");
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Map.Entry<String, String> getValue1() {
return ENTRY1;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Map.Entry<String, String> getValue2() {
return ENTRY2;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableEntry<String, String> getMutable(Map.Entry<String, String> value) {
return new MutableEntry<>(value.getKey(), value.getValue());
}
}

37
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableFloatTest.java Normal file
View File

@@ -0,0 +1,37 @@
package org.dromara.hutool.core.lang.mutable;
/**
* @author huangchengxing
*/
public class MutableFloatTest extends BaseMutableTest<Number, MutableFloat> {
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue1() {
return Float.MAX_VALUE;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue2() {
return Float.MIN_VALUE;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableFloat getMutable(Number value) {
return new MutableFloat(value);
}
}

37
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableIntTest.java Normal file
View File

@@ -0,0 +1,37 @@
package org.dromara.hutool.core.lang.mutable;
/**
* @author huangchengxing
*/
public class MutableIntTest extends BaseMutableTest<Number, MutableInt> {
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue1() {
return Integer.MAX_VALUE;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue2() {
return Integer.MIN_VALUE;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableInt getMutable(Number value) {
return new MutableInt(value);
}
}

37
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableLongTest.java Normal file
View File

@@ -0,0 +1,37 @@
package org.dromara.hutool.core.lang.mutable;
/**
* @author huangchengxing
*/
public class MutableLongTest extends BaseMutableTest<Number, MutableLong> {
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue1() {
return Long.MAX_VALUE;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue2() {
return Long.MIN_VALUE;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableLong getMutable(Number value) {
return new MutableLong(value);
}
}

40
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableObjTest.java Normal file
View File

@@ -0,0 +1,40 @@
package org.dromara.hutool.core.lang.mutable;
/**
* test for {@link MutableObj}
*
* @author huangchengxing
*/
class MutableObjTest extends BaseMutableTest<String, MutableObj<String>> {
/**
* 创建一个值
*
* @return 值
*/
@Override
String getValue1() {
return "test1";
}
/**
* 创建一个值
*
* @return 值
*/
@Override
String getValue2() {
return "test2";
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableObj<String> getMutable(String value) {
return new MutableObj<>(value);
}
}

37
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableShortTest.java Normal file
View File

@@ -0,0 +1,37 @@
package org.dromara.hutool.core.lang.mutable;
/**
* @author huangchengxing
*/
public class MutableShortTest extends BaseMutableTest<Number, MutableShort> {
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue1() {
return Short.MAX_VALUE;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
Number getValue2() {
return Short.MIN_VALUE;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableShort getMutable(Number value) {
return new MutableShort(value);
}
}

41
hutool-core/src/test/java/org/dromara/hutool/core/lang/mutable/MutableTripleTest.java Normal file
View File

@@ -0,0 +1,41 @@
package org.dromara.hutool.core.lang.mutable;
/**
* @author huangchengxing
*/
public class MutableTripleTest extends BaseMutableTest<MutableTriple<String, String, String>, MutableTriple<String, String, String>> {
private static final MutableTriple<String, String, String> VALUE1 = new MutableTriple<>("1", "2", "3");
private static final MutableTriple<String, String, String> VALUE2 = new MutableTriple<>("4", "5", "6");
/**
* 创建一个值，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
MutableTriple<String, String, String> getValue1() {
return VALUE1;
}
/**
* 创建一个值，与{@link #getValue1()}不同，且反复调用应该返回完全相同的值
*
* @return 值
*/
@Override
MutableTriple<String, String, String> getValue2() {
return VALUE2;
}
/**
* 创建一个{@link Mutable}
*
* @param value 值
* @return 值
*/
@Override
MutableTriple<String, String, String> getMutable(MutableTriple<String, String, String> value) {
return new MutableTriple<>(value.getLeft(), value.getMiddle(), value.getRight());
}
}