plusone
/
plusone-commons
1
0
Fork 1
Code Issues 2 Pull Requests Releases Activity

Compare commits

base: plusone:4559636e7d4ccd04bb135831a0067d0203566cbf
Branches Tags
plusone:1.x.x
plusone:dev
plusone:feature/security
plusone:feature/seq
plusone:feature/net-util
..
compare: plusone:f93eec6d086400cb655d0dad55d4660bedf00210
Branches Tags
plusone:1.x.x
plusone:dev
plusone:feature/security
plusone:feature/seq
plusone:feature/net-util

No commits in common. "4559636e7d4ccd04bb135831a0067d0203566cbf" and "f93eec6d086400cb655d0dad55d4660bedf00210" have entirely different histories.
4559636e7d ... f93eec6d08

11 changed files with 96 additions and 180 deletions
Show Stats Expand all files Collapse all files

48
src/main/java/xyz/zhouxy/plusone/commons/exception/ParsingFailureException.java
View File

@ -18,9 +18,6 @@ package xyz.zhouxy.plusone.commons.exception;
import java.time.format.DateTimeParseException;
import javax.annotation.Nonnull;
import xyz.zhouxy.plusone.commons.base.IWithCode;
import xyz.zhouxy.plusone.commons.exception.business.RequestParamsException;
/**
@ -29,10 +26,7 @@ import xyz.zhouxy.plusone.commons.exception.business.RequestParamsException;
* <p>
* 解析失败的不一定是客户传的参数，也可能是其它来源的数据解析失败。
* 如果表示用户传参造成的解析失败，可使用 {@link RequestParamsException#RequestParamsException(Throwable)}，
* 将 ParsingFailureException 包装成 {@link RequestParamsException} 再抛出。
* <pre>
* throw new RequestParamsException(ParsingFailureException.of(ParsingFailureException.Type.NUMBER_PARSING_FAILURE));
* </pre>
* 将 ParsingFailureException 包装成 {@link RequestParamsException} 再抛出
* </p>
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
@ -62,22 +56,6 @@ public final class ParsingFailureException extends RuntimeException {
this.type = type;
}
public ParsingFailureException() {
this(Type.DEFAULT);
}
public ParsingFailureException(String msg) {
this(Type.DEFAULT, msg);
}
public ParsingFailureException(Throwable e) {
this(Type.DEFAULT, e);
}
public ParsingFailureException(String msg, Throwable e) {
this(Type.DEFAULT, msg, e);
}
public static ParsingFailureException of(Type type) {
return new ParsingFailureException(type);
}
@ -102,29 +80,19 @@ public final class ParsingFailureException extends RuntimeException {
return new ParsingFailureException(Type.DATE_TIME_PARSING_FAILURE, msg, e);
}
public static ParsingFailureException of(NumberFormatException e) {
return new ParsingFailureException(Type.NUMBER_PARSING_FAILURE, e.getMessage(), e);
}
public static ParsingFailureException of(String msg, NumberFormatException e) {
return new ParsingFailureException(Type.NUMBER_PARSING_FAILURE, msg, e);
}
public Type getType() {
return type;
}
public enum Type implements IWithCode<String> {
DEFAULT("00", "解析失败"),
NUMBER_PARSING_FAILURE("10", "数字转换失败"),
DATE_TIME_PARSING_FAILURE("20", "时间解析失败"),
JSON_PARSING_FAILURE("30", "JSON 解析失败"),
XML_PARSING_FAILURE("40", "XML 解析失败"),
public enum Type {
DEFAULT("4010500", "解析失败"),
NUMBER_PARSING_FAILURE("4010501", "数字转换失败"),
DATE_TIME_PARSING_FAILURE("4010502", "时间解析失败"),
JSON_PARSING_FAILURE("4010503", "JSON 解析失败"),
XML_PARSING_FAILURE("4010504", "XML 解析失败"),
;
@Nonnull
final String code;
@Nonnull
final String defaultMsg;
Type(String code, String defaultMsg) {
@ -132,8 +100,6 @@ public final class ParsingFailureException extends RuntimeException {
this.defaultMsg = defaultMsg;
}
@Override
@Nonnull
public String getCode() {
return code;
}

24
src/main/java/xyz/zhouxy/plusone/commons/exception/business/InvalidInputException.java
View File

@ -16,10 +16,6 @@
package xyz.zhouxy.plusone.commons.exception.business;
import javax.annotation.Nonnull;
import xyz.zhouxy.plusone.commons.base.IWithCode;
/**
* InvalidInputException
*
@ -57,22 +53,6 @@ public final class InvalidInputException extends RequestParamsException {
this.type = type;
}
public InvalidInputException() {
this(Type.DEFAULT);
}
public InvalidInputException(String msg) {
this(Type.DEFAULT, msg);
}
public InvalidInputException(Throwable e) {
this(Type.DEFAULT, e);
}
public InvalidInputException(String msg, Throwable e) {
this(Type.DEFAULT, msg, e);
}
public static InvalidInputException of(Type type) {
return new InvalidInputException(type);
}
@ -101,7 +81,7 @@ public final class InvalidInputException extends RequestParamsException {
return type;
}
public enum Type implements IWithCode<String> {
public enum Type {
DEFAULT("00", "用户输入内容非法"),
CONTAINS_ILLEGAL_AND_MALICIOUS_LINKS("01", "包含非法恶意跳转链接"),
CONTAINS_ILLEGAL_WORDS("02", "包含违禁敏感词"),
@ -117,8 +97,6 @@ public final class InvalidInputException extends RequestParamsException {
this.defaultMsg = defaultMsg;
}
@Override
@Nonnull
public String getCode() {
return code;
}

8
src/main/java/xyz/zhouxy/plusone/commons/model/Gender.java
View File

@ -16,7 +16,6 @@
package xyz.zhouxy.plusone.commons.model;
import xyz.zhouxy.plusone.commons.base.IWithIntCode;
import xyz.zhouxy.plusone.commons.util.AssertTools;
/**
@ -24,7 +23,7 @@ import xyz.zhouxy.plusone.commons.util.AssertTools;
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
*/
public enum Gender implements IWithIntCode {
public enum Gender {
UNKNOWN(0, "Unknown", "未知"),
MALE(1, "Male", "男"),
FEMALE(2, "Female", "女"),
@ -61,9 +60,4 @@ public enum Gender implements IWithIntCode {
return displayNameZh;
}
@Override
public int getCode() {
return getValue();
}
}

5
src/main/java/xyz/zhouxy/plusone/commons/model/dto/PageResult.java
View File

@ -18,8 +18,9 @@ package xyz.zhouxy.plusone.commons.model.dto;
import java.util.List;
import com.google.common.base.Preconditions;
import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
import xyz.zhouxy.plusone.commons.util.AssertTools;
/**
* 返回分页查询的结果
@ -36,7 +37,7 @@ public class PageResult<T> {
private final List<T> content;
private PageResult(List<T> content, long total) {
AssertTools.checkNotNull(content, "Content must not be null.");
Preconditions.checkNotNull(content, "Content must not be null.");
this.content = content;
this.total = total;
}

21
src/main/java/xyz/zhouxy/plusone/commons/model/dto/PagingAndSortingQueryParams.java
View File

@ -21,15 +21,12 @@ import java.util.Map;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import xyz.zhouxy.plusone.commons.annotation.Virtual;
import xyz.zhouxy.plusone.commons.collection.CollectionTools;
import xyz.zhouxy.plusone.commons.util.AssertTools;
import xyz.zhouxy.plusone.commons.util.RegexTools;
import xyz.zhouxy.plusone.commons.util.StringTools;
/**
@ -51,15 +48,15 @@ public class PagingAndSortingQueryParams {
private Long pageNum;
private List<String> orderBy;
private static final Pattern SORT_STR_PATTERN = Pattern.compile("^[a-zA-Z]\\w+-(desc|asc|DESC|ASC)$");
private static final Pattern sortStrPattern = Pattern.compile("^[a-zA-Z]\\w+-(desc|asc|DESC|ASC)$");
private final Map<String, String> sortableProperties;
public PagingAndSortingQueryParams(@Nonnull Map<String, String> sortableProperties) {
AssertTools.checkArgument(CollectionTools.isNotEmpty(sortableProperties),
public PagingAndSortingQueryParams(Map<String, String> sortableProperties) {
Preconditions.checkArgument(sortableProperties != null && !sortableProperties.isEmpty(),
"Sortable properties can not be empty.");
sortableProperties.forEach((k, v) ->
AssertTools.checkArgument(StringTools.isNotBlank(k) && StringTools.isNotBlank(v),
Preconditions.checkArgument(StringTools.isNotBlank(k) && StringTools.isNotBlank(v),
"Property name must not be blank."));
this.sortableProperties = ImmutableMap.copyOf(sortableProperties);
}
@ -104,12 +101,12 @@ public class PagingAndSortingQueryParams {
}
private SortableProperty generateSortableProperty(String orderByStr) {
AssertTools.checkArgument(RegexTools.matches(orderByStr, SORT_STR_PATTERN));
Preconditions.checkArgument(PagingAndSortingQueryParams.sortStrPattern.matcher(orderByStr).matches());
String[] propertyNameAndOrderType = orderByStr.split("-");
AssertTools.checkArgument(propertyNameAndOrderType.length == 2);
Preconditions.checkArgument(propertyNameAndOrderType.length == 2);
String propertyName = propertyNameAndOrderType[0];
AssertTools.checkArgument(sortableProperties.containsKey(propertyName),
Preconditions.checkArgument(sortableProperties.containsKey(propertyName),
"The property name must be in the set of sortable properties.");
String columnName = sortableProperties.get(propertyName);
String orderType = propertyNameAndOrderType[1];
@ -126,7 +123,7 @@ public class PagingAndSortingQueryParams {
SortableProperty(String propertyName, String columnName, String orderType) {
this.propertyName = propertyName;
this.columnName = columnName;
AssertTools.checkArgument("ASC".equalsIgnoreCase(orderType) || "DESC".equalsIgnoreCase(orderType));
Preconditions.checkArgument("ASC".equalsIgnoreCase(orderType) || "DESC".equalsIgnoreCase(orderType));
this.orderType = orderType.toUpperCase();
this.sqlSnippet = this.propertyName + " " + this.orderType;

19
src/main/java/xyz/zhouxy/plusone/commons/time/Quarter.java
View File

@ -23,15 +23,13 @@ import java.time.temporal.ChronoField;
import com.google.common.collect.Range;
import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
import xyz.zhouxy.plusone.commons.base.IWithIntCode;
import xyz.zhouxy.plusone.commons.util.AssertTools;
/**
* 季度
*
* @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
*/
public enum Quarter implements IWithIntCode {
public enum Quarter {
/** 第一季度 */
Q1(1),
/** 第二季度 */
@ -109,7 +107,10 @@ public enum Quarter implements IWithIntCode {
*/
@StaticFactoryMethod(Quarter.class)
public static Quarter of(int value) {
return ENUMS[checkValidIntValue(value) - 1];
if (value < 1 || value > 4) {
throw new IllegalArgumentException("Invalid value for Quarter: " + value);
}
return ENUMS[value - 1];
}
// StaticFactoryMethods end
@ -133,11 +134,6 @@ public enum Quarter implements IWithIntCode {
return value;
}
@Override
public int getCode() {
return getValue();
}
public Month firstMonth() {
return Month.of(firstMonthValue());
}
@ -170,11 +166,6 @@ public enum Quarter implements IWithIntCode {
// Getters end
public static int checkValidIntValue(int value) {
AssertTools.checkArgument(value >= 1 && value <= 4, () -> "Invalid value for Quarter: " + value);
return value;
}
// Internal
/**

32
src/main/java/xyz/zhouxy/plusone/commons/time/YearQuarter.java
View File

@ -59,7 +59,7 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
this.lastDate = quarter.lastMonthDay().atYear(year);
}
// #region - StaticFactory
// #region - StaticFactoryMethod
/**
* 根据指定年份与季度，创建 {@link YearQuarter} 实例
@ -186,7 +186,7 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
// #region - computes
public YearQuarter plusQuarters(long quartersToAdd) { // TODO 单元测试
if (quartersToAdd == 0L) {
if (quartersToAdd == 0) {
return this;
}
long quarterCount = this.year * 4L + (this.quarter.getValue() - 1);
@ -200,16 +200,8 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
return plusQuarters(-quartersToAdd);
}
public YearQuarter nextQuarter() { // TODO 单元测试
return plusQuarters(1L);
}
public YearQuarter lastQuarter() { // TODO 单元测试
return minusQuarters(1L);
}
public YearQuarter plusYears(long yearsToAdd) { // TODO 单元测试
if (yearsToAdd == 0L) {
if (yearsToAdd == 0) {
return this;
}
int newYear = YEAR.checkValidIntValue(this.year + yearsToAdd); // safe overflow
@ -220,14 +212,6 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
return plusYears(-yearsToAdd);
}
public YearQuarter nextYear() {
return plusYears(1L);
}
public YearQuarter lastYear() {
return minusYears(1L);
}
// #endregion
// #region - hashCode & equals
@ -251,7 +235,7 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
// #endregion
// #region - compare
// #region - compareTo
@Override
public int compareTo(YearQuarter other) {
@ -270,14 +254,6 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
return this.compareTo(other) > 0;
}
public static YearQuarter min(YearQuarter yearQuarter1, YearQuarter yearQuarter2) { // TODO 单元测试
return yearQuarter1.compareTo(yearQuarter2) <= 0 ? yearQuarter1 : yearQuarter2;
}
public static YearQuarter max(YearQuarter yearQuarter1, YearQuarter yearQuarter2) { // TODO 单元测试
return yearQuarter1.compareTo(yearQuarter2) >= 0 ? yearQuarter1 : yearQuarter2;
}
// #endregion
// #region - toString

107
src/main/java/xyz/zhouxy/plusone/commons/util/EnumTools.java
View File

@ -20,6 +20,8 @@ import java.util.function.Supplier;
import javax.annotation.Nullable;
import com.google.common.base.Preconditions;
/**
* 枚举工具类
*
@ -34,18 +36,18 @@ public final class EnumTools {
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E valueOf(Class<E> enumType, int ordinal) { // NOSONAR 该方法弃用，但不删掉
AssertTools.checkNotNull(enumType, "Enum type must not be null.");
E[] values = enumType.getEnumConstants();
public static <E extends Enum<?>> E valueOf(Class<E> clazz, int ordinal) { // NOSONAR 该方法弃用，但不删掉
Preconditions.checkNotNull(clazz, "Clazz must not be null.");
E[] values = clazz.getEnumConstants();
AssertTools.checkCondition((ordinal >= 0 && ordinal < values.length),
() -> new EnumConstantNotPresentException(enumType, Integer.toString(ordinal)));
() -> new EnumConstantNotPresentException(clazz, Integer.toString(ordinal)));
return values[ordinal];
}
@ -53,23 +55,25 @@ public final class EnumTools {
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @param defaultValue 默认值
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E valueOf(Class<E> enumType, // NOSONAR 该方法弃用，但不删掉
@Nullable Integer ordinal, E defaultValue) {
return null == ordinal ? defaultValue : valueOf(enumType, ordinal);
public static <E extends Enum<?>> E valueOf(Class<E> clazz, @Nullable Integer ordinal, E defaultValue) { // NOSONAR 该方法弃用，但不删掉
if (null == ordinal) {
return defaultValue;
}
return valueOf(clazz, ordinal);
}
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @param defaultValue 默认值
* @return 枚举对象
@ -77,26 +81,29 @@ public final class EnumTools {
*/
@Deprecated
public static <E extends Enum<?>> E getValueOrDefault( // NOSONAR 该方法弃用，但不删掉
Class<E> enumType,
Class<E> clazz,
@Nullable Integer ordinal,
Supplier<E> defaultValue) {
return null == ordinal ? defaultValue.get() : valueOf(enumType, ordinal);
if (null == ordinal) {
return defaultValue.get();
}
return valueOf(clazz, ordinal);
}
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E getValueOrDefault(Class<E> enumType, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return getValueOrDefault(enumType, ordinal, () -> {
AssertTools.checkNotNull(enumType, "Enum type must not be null.");
E[] values = enumType.getEnumConstants();
public static <E extends Enum<?>> E getValueOrDefault(Class<E> clazz, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return getValueOrDefault(clazz, ordinal, () -> {
Preconditions.checkNotNull(clazz, "Clazz must not be null.");
E[] values = clazz.getEnumConstants();
return values[0];
});
}
@ -104,65 +111,69 @@ public final class EnumTools {
/**
* 通过 ordinal 获取枚举实例
*
* @param <E> 枚举的类型
* @param enumType 枚举的类型信息
* @param ordinal 序号
* @param <E> 枚举的类型
* @param clazz 枚举的类型信息
* @param ordinal 序号
* @return 枚举对象
* @deprecated 不推荐使用枚举的 ordinal。
*/
@Deprecated
public static <E extends Enum<?>> E getValueNullable(Class<E> enumType, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return valueOf(enumType, ordinal, null);
public static <E extends Enum<?>> E getValueNullable(Class<E> clazz, @Nullable Integer ordinal) { // NOSONAR 该方法弃用，但不删掉
return valueOf(clazz, ordinal, null);
}
public static <E extends Enum<?>> Integer checkOrdinal(Class<E> enumType, Integer ordinal) {
AssertTools.checkNotNull(enumType, "Enum type must not be null.");
AssertTools.checkNotNull(ordinal, "Ordinal must not be null.");
E[] values = enumType.getEnumConstants();
AssertTools.checkCondition(ordinal >= 0 && ordinal < values.length,
() -> new EnumConstantNotPresentException(enumType, Integer.toString(ordinal)));
return ordinal;
public static <E extends Enum<?>> Integer checkOrdinal(Class<E> clazz, Integer ordinal) {
Preconditions.checkNotNull(clazz, "Clazz must not be null.");
Preconditions.checkNotNull(ordinal, "Ordinal must not be null.");
E[] values = clazz.getEnumConstants();
if (ordinal >= 0 && ordinal < values.length) {
return ordinal;
}
throw new EnumConstantNotPresentException(clazz, Integer.toString(ordinal));
}
/**
* 校验枚举的 ordinal。
*
* @param <E> 枚举类型
* @param enumType 枚举类型
* @param ordinal The ordinal
* @param <E> 枚举类型
* @param clazz 枚举类型
* @param ordinal The ordinal
* @return The ordinal
*/
@Nullable
public static <E extends Enum<?>> Integer checkOrdinalNullable(Class<E> enumType, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(enumType, ordinal, null);
public static <E extends Enum<?>> Integer checkOrdinalNullable(Class<E> clazz, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(clazz, ordinal, null);
}
/**
* 校验枚举的 ordinal，如果 ordinal 为 {@code null}，则返回 {@code 0}。
*
* @param <E> 枚举类型
* @param enumType 枚举类型
* @param ordinal The ordinal
* @param <E> 枚举类型
* @param clazz 枚举类型
* @param ordinal The ordinal
* @return The ordinal
*/
@Nullable
public static <E extends Enum<?>> Integer checkOrdinalOrDefault(Class<E> enumType, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(enumType, ordinal, 0);
public static <E extends Enum<?>> Integer checkOrdinalOrDefault(Class<E> clazz, @Nullable Integer ordinal) {
return checkOrdinalOrDefault(clazz, ordinal, 0);
}
/**
* 校验枚举的 ordinal，如果 ordinal 为 {@code null}，则返回 {@code defaultValue}。
*
* @param <E> 枚举类型
* @param enumType 枚举类型
* @param ordinal The ordinal
* @param <E> 枚举类型
* @param clazz 枚举类型
* @param ordinal The ordinal
* @return The ordinal
*/
@Nullable
public static <E extends Enum<?>> Integer checkOrdinalOrDefault(
Class<E> enumType,
Class<E> clazz,
@Nullable Integer ordinal,
@Nullable Integer defaultValue) {
return ordinal != null ? checkOrdinal(enumType, ordinal) : defaultValue;
if (ordinal != null) {
return checkOrdinal(clazz, ordinal);
}
return defaultValue;
}
}

6
src/main/java/xyz/zhouxy/plusone/commons/util/Enumeration.java
View File

@ -24,6 +24,8 @@ import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import com.google.common.base.Preconditions;
import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
/**
@ -41,7 +43,7 @@ public abstract class Enumeration<T extends Enumeration<T>> // NOSONAR 暂不移
protected final String name;
protected Enumeration(final int id, final String name) {
AssertTools.checkArgument(StringTools.isNotBlank(name), "Name of enumeration must has text.");
Preconditions.checkArgument(StringTools.isNotBlank(name), "Name of enumeration must has text.");
this.id = id;
this.name = name;
}
@ -96,7 +98,7 @@ public abstract class Enumeration<T extends Enumeration<T>> // NOSONAR 暂不移
}
public T get(int id) {
AssertTools.checkArgument(this.valueMap.containsKey(id), "[%s] 对应的值不存在", id);
Preconditions.checkArgument(this.valueMap.containsKey(id), "[%s] 对应的值不存在", id);
return this.valueMap.get(id);
}

2
src/test/java/xyz/zhouxy/plusone/commons/model/dto/test/PagingAndSortingQueryParamsTests.java → src/test/java/xyz/zhouxy/plusone/commons/queryparams/test/PagingAndSortingQueryParamsTests.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package xyz.zhouxy.plusone.commons.model.dto.test;
package xyz.zhouxy.plusone.commons.queryparams.test;
import java.io.IOException;
import java.time.LocalDate;

4
src/test/java/xyz/zhouxy/plusone/commons/time/YearQuarterTests.java
View File

@ -59,8 +59,8 @@ public class YearQuarterTests {
void of_ValidYearQuarter_GetsCorrectStartAndEndDate() {
for (int year = 1990; year <= 2024; year++) {
for (int quarterValue = 1; quarterValue <= 4; quarterValue++) {
Quarter quarter = Quarter.of(quarterValue);
for (int qrtr = 1; qrtr <= 4; qrtr++) {
Quarter quarter = Quarter.of(qrtr);
YearQuarter yearQuarter = YearQuarter.of(year, quarter);
LocalDate expectedStartDate = quarter.firstMonthDay().atYear(year);