Taogen's Blog

return ResponseEntity.ok()
    .cacheControl(CacheControl.maxAge(365, TimeUnit.DAYS)
                  .cachePrivate()
                  .mustRevalidate())
    .contentType(MediaType.parseMediaType("application/octet-stream"))
    .header(HttpHeaders.CONTENT_DISPOSITION, "inline; filename=\"" + fileName + "\"")
    .body(resource);

System.getenv("msg")

@Autowired
private Environment environment;

environment.getProperty("msg")

@Value("${msg}")
private String msg;

SysUser user = new SysUser();
SysDept dept = new SysDept();
dept.setDeptName("development");
user.setDept(dept);
Optional<String> optional = Optional.ofNullable(user)
    .map(SysUser::getDept)
    .map(SysDept::getDeptName);
optional.ifPresent(System.out::println);
String deptName = optional.orElse("default");
String deptName = optional.orElseGet(() -> "to get default");
optional.orElseThrow(() -> new RuntimeException("to throw exception"));

list.stream()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

Arrays.stream(arr);
Stream.of(arr);

Stream<String> streamOfArray
            = Stream.empty();

Stream.Builder<String> builder = Stream.builder();
Stream<String> stream = builder.add("a").add("b").add("c").build();

Stream.iterate(seedValue, (Integer n) -> n * n)
            .limit(limitTerms)
            .forEach(System.out::println);

Stream.generate(Math::random)
            .limit(limitTerms)
            .forEach(System.out::println);

Iterator<String> iterator = Arrays.asList("a", "b", "c").iterator();
Spliterator<T> spitr = Spliterators.spliteratorUnknownSize(iterator, Spliterator.NONNULL);
Stream<T> stream = StreamSupport.stream(spitr, false);

Iterable<String> iterable = Arrays.asList("a", "b", "c");
Stream<T> stream = StreamSupport.stream(iterable.spliterator(), false);

// only array
String[] stringArray = new String[10];
Object[] objectArray = stringArray;

// list
List<String> stringList = new ArrayList<>();
List<Object> objectList = new ArrayList<>(stringList);

// set
Set<String> stringSet = new HashSet<>();
Set<Object> objectSet = new HashSet<>(stringSet);

// multiStringValueMap to multiObjectValueMap
Map<String, List<String>> multiStringValueMap = new HashMap<>();
multiStringValueMap.put("key1", Arrays.asList("taogen", "taogen2"));
multiStringValueMap.put(null, Arrays.asList(null, null, null));
multiStringValueMap.put("testNullValue", null);
Map<String, List<Object>> multiObjectValueMap = new HashMap<>();
multiStringValueMap.forEach((key, value) -> {
    List<Object> objectList = null;
    if (value != null) {
        objectList = value.stream()
            .collect(Collectors.toList());
    }
    multiObjectValueMap.put(key, objectList);
});
System.out.println(multiObjectValueMap);

List<Object> objectList = new ArrayList<>();
List<String> stringList = objectList.stream()
    .map(object -> Objects.toString(object, null))
    .collect(Collectors.toList());
for (Object s : objectList) {
    System.out.println(s + ", isNull: " + Objects.isNull(s));
}

List<Object> objectList = new ArrayList<>();
List<String> stringList = new ArrayList<>(objectList.size());
for (Object object : objectList) {
    stringList.add(Objects.toString(object, null));
}
for (Object s : objectList) {
    System.out.println(s + ", isNull: " + Objects.isNull(s));
}

// multiObjectValueMap to multiStringValueMap
Map<String, List<Object>> multiObjectValueMap = new HashMap<>();
multiObjectValueMap.put("key1", Arrays.asList(1, 2, 3));
multiObjectValueMap.put(null, Arrays.asList(null, null, null));
multiObjectValueMap.put("testNullValue", null);
multiObjectValueMap.put("key2", Arrays.asList("taogen", "taogen2"));
Map<String, List<String>> multiStringValueMap = new HashMap<>();
multiObjectValueMap.forEach((key, value) -> {
    List<String> stringList = null;
    if (value != null) {
        stringList = value.stream()
            .map(object -> Objects.toString(object, null))
            .collect(Collectors.toList());
    }
    multiStringValueMap.put(key, stringList);
});
System.out.println(multiStringValueMap);

// use list.toArray()
User[] users = userList.toArray(new User[0]);
Integer[] integers = integerList.toArray(new Integer[0]);
String[] strings = stringList.toArray(new String[0]);

// use Java 8 stream
User[] users = userList.stream().toArray(User[]::new);
Integer[] integers = integerList.stream().toArray(Integer[]::new);
String[] strings = stringList.stream().toArray(String[]::new);
// Java 11
String[] strings = stringList.toArray(String[]::new);

// use for loop
int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++) array[i] = list.get(i);

Set<String> set = new HashSet();
ArrayList<String> list = new ArrayList(set);

list.addAll(set);

// Java 8
List<String> list = set.stream().collect(Collectors.toList());

// Java 10
var list = List.copyOf(set);

String[] array = new String[10];
Integer[] array2 = new Integer[10];
ArrayList<String> list = new ArrayList(Arrays.asList(array));

// use Arrays.stream()
int[] input = new int[]{1,2,3,4};
List<Integer> output = Arrays.stream(input).boxed().collect(Collectors.toList());

// use IntStream.of()
int[] input = new int[]{1,2,3,4};
List<Integer> output = IntStream.of(input).boxed().collect(Collectors.toList());

ArrayList<String> list = new ArrayList();
Set<String> set = new HashSet(list);

set.addAll(aList);

// Java 8
Set<String> set = list.stream().collect(Collectors.toSet());

// Java 10
var set = Set.copyOf(list);

String[] array = new String[10];
Set<String> set = new HashSet(Arrays.asList(array));

// to LinkedHashSet
list.stream().collect(Collectors.toCollection(LinkedHashSet::new))

List<SysUser> sysUserList = getUserList();
Map<Long, String> idToName = sysUserList.stream()
    .collect(Collectors.toMap(SysUser::getId, SysUser::getName));
// or
Map<Long, String> idToName = sysUserList.stream()
    .collect(Collectors.toMap(item -> item.getId(), item -> item.getName()));

List<IdName> list = getIdNameList();
Map<Long, IdName> idToObjMap = list.stream()
    .collect(Collectors.toMap(IdName::getId, Function.identity()));
// or
Map<Long, IdName> idToObjMap = list.stream()
    .collect(Collectors.toMap(item -> item.getId(), item -> item));

// to TreeMap
List<IdName> idNameList = new ArrayList<>();
Map<Integer,String> idToNameMap = idNameList.stream().collect(Collectors.toMap(IdName::getId, IdName::getName, (o1, o2) -> o1, TreeMap::new));

// to ConcurrentMap
List<IdName> idNameList = new ArrayList<>();
idNameList.stream().collect(Collectors.toConcurrentMap(IdName::getId, IdName::getName));

byte[] one = getBytesForOne();
byte[] two = getBytesForTwo();
byte[] combined = new byte[one.length + two.length];

System.arraycopy(one,0,combined,0         ,one.length);
System.arraycopy(two,0,combined,one.length,two.length);

byte[] one = getBytesForOne();
byte[] two = getBytesForTwo();

List<Byte> list = new ArrayList<Byte>(Arrays.<Byte>asList(one));
list.addAll(Arrays.<Byte>asList(two));

byte[] combined = list.toArray(new byte[list.size()]);

byte[] allByteArray = new byte[one.length + two.length + three.length];

ByteBuffer buff = ByteBuffer.wrap(allByteArray);
buff.put(one);
buff.put(two);
buff.put(three);

byte[] combined = buff.array();

@Data
public class IdName {
    private String id;
    private String name;
    private String parentId;
    private List<IdName> children;

    public IdName(String id, String name, String parentId) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
    }

    private void putChildren(IdName idName) {
        if (this.children == null) {
            this.children = new ArrayList<>();
        }
        this.children.add(idName);
    }

    public static List<IdName> convertListToTree(List<IdName> list) {
        if (list == null || list.isEmpty()) {
            return Collections.emptyList();
        }
        Map<String, IdName> map = list.stream()
            .collect(Collectors.toMap(IdName::getId, Function.identity()));
        List<IdName> firstLevelNodeList = new ArrayList<>();
        for (IdName idName : list) {
            IdName parent = map.get(String.valueOf(idName.getParentId()));
            if (parent != null) {
                parent.putChildren(idName);
            } else {
                firstLevelNodeList.add(idName);
            }
        }
        return firstLevelNodeList;
    }
}

public static void main(String[] args) {
    List<IdName> idNames = new ArrayList<>();
    idNames.add(new IdName("1", "Jack", "0"));
    idNames.add(new IdName("2", "Tom", "0"));
    idNames.add(new IdName("3", "Jerry", "1"));
    System.out.println(IdName.convertListToTree(idNames));
}

public List<AreaVo> getAreaVoList() {
    List<Province> provinces = iProvinceService.list(
        new LambdaQueryWrapper<Province>()
        .select(Province::getId, Province::getName, Province::getCode));
    List<City> cities = iCityService.list(
        new LambdaQueryWrapper<City>()
        .select(City::getId, City::getName, City::getCode, City::getProvinceCode));
    List<County> counties = iCountyService.list(
        new LambdaQueryWrapper<County>()
        .select(County::getId, County::getName, County::getCode, County::getCityCode));
    List<AreaVo> resultList = new ArrayList<>();
    resultList.addAll(AreaVo.fromProvince(provinces));
    resultList.addAll(AreaVo.fromCity(cities));
    resultList.addAll(AreaVo.fromCounty(counties));
    return AreaVo.convertListToTree(resultList);
}

public class AreaVo {
    private String label;
    private String value;
    private String parentId;
    private List<AreaVo> children;

    public static List<AreaVo> fromProvince(List<Province> provinces) {
        if (provinces == null || provinces.isEmpty()) {
            return Collections.emptyList();
        }
        return provinces.stream()
            .map(item -> new AreaVo(item.getName(), item.getCode(), "0"))
            .sorted(Comparator.comparing(AreaVo::getValue))
            .collect(Collectors.toList());
    }
    public static List<AreaVo> convertListToTree(List<AreaVo> list) {}
}

private void setAreaForList(List<User> records) {
    List<String> areaCodeList = records.stream()
        .map(User::getAreaId)
        .filter(Objects::nonNull)
        .map(String::valueOf)
        .collect(Collectors.toList());

    List<AreaItem> areaItemList = iAreaService.findSelfAndAncestors(areaCodeList);
    if (areaItemList == null || areaItemList.isEmpty()) {
        return;
    }
    Map<String, AreaItem> areaItemMap = areaItemList.stream()
        .collect(Collectors.toMap(AreaItem::getCode, Function.identity()));
    records.stream()
        .filter(entity -> entity.getAreaId() != null)
        .forEach(entity -> {
            List<AreaItem> areaPath = new ArrayList<>();
            String areaCode = entity.getAreaId().toString();
            String tempCode = areaCode;
            AreaItem areaItem = null;
            while ((areaItem = areaItemMap.get(tempCode)) != null) {
                areaPath.add(0, areaItem);
                tempCode = areaItem.getParentCode();
            }
            if (CollectionUtils.isEmpty(areaPath)) {
                return;
            }
            int totalLevel = 2;
            if (areaPath.size() < totalLevel) {
                int supplementSize = totalLevel - areaPath.size();
                for (int i = 0; i < supplementSize; i++) {
                    areaPath.add(null);
                }
            } else {
                areaPath = areaPath.subList(0, totalLevel);
            }
            entity.setAreaPath(areaPath);
            entity.setAreaArray(areaPath.stream()
                                .map(areaPathItem -> areaPathItem == null ? null : areaPathItem.getCode())
                                .collect(Collectors.toList()));
        });
}

public List<AreaItem> findSelfAndAncestors(List<String> areaCodeList) {
    if (CollectionUtils.isEmpty(areaCodeList)) {
        return Collections.emptyList();
    }
    List<String> tempCodeList = areaCodeList;
    List<AreaItem> resultAreaList = new ArrayList<>();
    List<AreaCounty> countyList = iAreaCountyService.list(
        new LambdaQueryWrapper<AreaCounty>()
        .select(AreaCounty::getCode, AreaCounty::getName, AreaCounty::getCityCode)
        .in(AreaCounty::getCode, tempCodeList));
    if (!CollectionUtils.isEmpty(countyList)) {
        AreaItem.fromAreaCounty(countyList)
            .forEach(areaItem -> {
                resultAreaList.add(areaItem);
                areaItem.setLevel(3);
            });
        tempCodeList = areaCodeList; 
        tempCodeList.addAll(countyList.stream()
                            .map(AreaCounty::getCityCode)
                            .collect(Collectors.toList()));
    }
    List<AreaCity> cityList = iAreaCityService.list(
        new LambdaQueryWrapper<AreaCity>()
        .select(AreaCity::getCode, AreaCity::getName, AreaCity::getProvinceCode)
        .in(AreaCity::getCode, tempCodeList));
    if (!CollectionUtils.isEmpty(cityList)) {
        AreaItem.fromAreaCity(cityList)
            .forEach(areaItem -> {
                resultAreaList.add(areaItem);
                areaItem.setLevel(2);
            });
        tempCodeList = areaCodeList;
        tempCodeList.addAll(cityList.stream()
                            .map(AreaCity::getProvinceCode)
                            .collect(Collectors.toList()));
    }
    List<AreaProvince> provinceList = iAreaProvinceService.list(
        new LambdaQueryWrapper<AreaProvince>()
        .select(AreaProvince::getCode, AreaProvince::getName)
        .in(AreaProvince::getCode, tempCodeList));
    if (!CollectionUtils.isEmpty(provinceList)) {
        AreaItem.fromAreaProvince(provinceList)
            .forEach(areaItem -> {
                resultAreaList.add(areaItem);
                areaItem.setLevel(1);
            });
    }
    return resultAreaList;
}

private List<User> findSelfAndDescendants(Integer parentId){
    List<User> resultList = new ArrayList<>();
    List<Integer> tempIds = new ArrayList<>();
    tempIds.add(parentId);
    List<User> descendants = null;
    while (!CollectionUtils.isEmpty(descendants = getListByIds(tempIds))) {
        resultList.addAll(descendants);
        tempIds.clear();
        tempIds = descendants.stream().map(User::getId).collect(Collectors.toList());
    }
    return resultList;
}
public List<User> getListByIds(List<Integer> ids){}

private List<User> findDescendants(Integer parentId){
    List<User> resultList = new ArrayList<>();
    List<Integer> tempIds = new ArrayList<>();
    tempIds.add(parentId);
    List<User> descendants = null;
    while (!CollectionUtils.isEmpty(descendants = getListByParentIds(tempIds))) {
        resultList.addAll(descendants);
        tempIds.clear();
        tempIds = descendants.stream().map(User::getId).collect(Collectors.toList());
    }
    return resultList;
}
public List<User> getListByParentIds(List<Integer> tempIds){}

private List<Integer> findSelfAndDescendantIds(Integer parentId){
    List<Integer> resultIds = new ArrayList<>();
    resultIds.add(id);
    List<Integer> tempIds = new ArrayList<>();
    tempIds.add(parentId);
    List<Integer> childrenIds = null;
    while (!CollectionUtils.isEmpty(childrenIds = getChildrenIdsByParentIds(tempIds))) {
        resultIds.addAll(childrenIds);
        tempIds.clear();
        tempIds.addAll(childrenIds);
    }
    return resultIds;
}
public List<Integer> getChildrenIdsByParentIds(List<Integer> parentIds){}

public Set<Integer> getDescendantIds(Integer deptId) {
    List<Object> descendantIds = new ArrayList<>();
    List<Object> childIds = this.baseMapper.selectObjs(new LambdaQueryWrapper<SysDept>()
                                                            .select(SysDept::getDeptId)
                                                            .eq(SysDept::getParentId, deptId));
    while (!CollectionUtils.isEmpty(childIds)) {
        descendantIds.add(childIds);
        childIds = this.baseMapper.selectObjs(new LambdaQueryWrapper<SysDept>()
                                                   .select(SysDept::getDeptId)
                                                   .in(SysDept::getParentId, childIds));
    }
    return descendantIds.stream()
        .map(Objects::toString)
        .filter(Objects::nonNull)
        .map(Integer::valueOf)
        .collect(Collectors.toSet());
}

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    int listSize = list.size();
    int handlingSize = 3;
    int startIndex = 0;
    int endIndex = handlingSize;
    while (startIndex < listSize) {
        if (endIndex > listSize) {
            endIndex = listSize;
        }
        handleList(list, startIndex, endIndex);
        startIndex = endIndex;
        endIndex = startIndex + handlingSize;
    }
}
private static void handleList(List<Integer> list, int start, int end) {
    for (int i = start; i < end; i++) {
        System.out.println(list.get(i));
    }
}

int a[] = new int[]{1, 2, 3};
System.out.println(Arrays.toString(a));

System.out.println(list);
System.out.println(set);
System.out.println(map);

List<String> names = Arrays.asList("Tom", "Jack", "Lucy");
System.out.println(names.stream().map(Object::toString).collect(Collectors.joining(",")));
List<Integer> ids = Arrays.asList(1, 2, 3);
System.out.println(ids.stream().map(Object::toString).collect(Collectors.joining(",")));

List<String> names = Arrays.asList("Tom", "Jack", "Lucy");
System.out.println(String.join(",", names));

List<Integer> list = Arrays.asList(1, 2, 3, 2, 3, 4);
list = list.stream().distinct().collect(Collectors.toList());
System.out.println(list);

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 2, 3, 4));
Set<Integer> set = new LinkedHashSet<>(list);
list.clear(); // note: clear Arrays.asList will throw UnsupportedOperationException
list.addAll(set);
System.out.println(list);

List<Integer> list = Arrays.asList(1, 2, 3, 2, 3, 4);
list = new ArrayList<>(new LinkedHashSet<>(list));
System.out.println(list);

List<User> userList = buildUserList();
System.out.println("Before: " + userList);
List<User> toRemoveList = new ArrayList<>();
for (User user : userList) {
    if (user.getUserName().contains("test")) {
        toRemoveList.add(user);
    }
}
userList.removeAll(toRemoveList);
System.out.println("After: " + userList);

List<IdName> list = new ArrayList<>();
list.add(new IdName(1, "a"));
list.add(new IdName(2, "a"));
list.add(new IdName(3, "a"));
list.add(new IdName(4, "b"));
list.add(new IdName(5, "b"));
list.add(new IdName(6, "c"));
List<Integer> indexToRemove = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
	if (i < list.size() - 1 && list.get(i).getName().equals(list.get(i + 1).getName())) {
		indexToRemove.add(i);
	}
}
for (int i = indexToRemove.size() - 1; i >= 0; i--) {
	list.remove(indexToRemove.get(i).intValue());
}
System.out.println(list);

Comparator<Employee> compareByFirstName = Comparator.comparing(Employee::getFirstName);
Comparator<Employee> compareByLastName = Comparator.comparing(Employee::getLastName);
Comparator<Employee> compareByFullName = compareByFirstName.thenComparing(compareByLastName);

Comparator<Employee> compareByName = Comparator
    .comparing(Employee::getFirstName)
    .thenComparing(Employee::getLastName);

Comparator<IdName> c = (o1, o2) -> {
    int i = o1.getFirstName().compareTo(o2.getFirstName());
    if (i != 0) {
        return i;
    }
    return o1.getLastName().compareTo(o2.getLastName());
};

Comparator<Employee> compareByName = Comparator
    .comparing(Employee::getFirstName, Comparator.nullsLast(Comparator.naturalOrder()))
    .thenComparing(Employee::getLastName, Comparator.nullsLast(Comparator.naturalOrder()));

Comparator<IdName> c = (o1, o2) -> {
    // nullsLast
    if (o1.getId() == null) {
        return 1;
    } else if (o2.getId() == null) {
        return -1;
    }
    int i = o1.getId().compareTo(o2.getId());
    if (i != 0) {
        return i;
    }
    // nullsLast
    if (o1.getName() == null) {
        return 1;
    } else if (o2.getName() == null) {
        return -1;
    }
    return o1.getName().compareTo(o2.getName());
};

List<Integer> list = new ArrayList<>(Arrays.asList(1, 3, 2, 6, 5, 4, 9, 7));
list.stream().sorted().forEachOrdered(System.out::print);
list.stream().sorted((o1, o2) -> o1 - o2).forEachOrdered(System.out::print);
list.stream().sorted(Comparator.comparingInt(o -> o)).forEachOrdered(System.out::print);

List<Animal> list = new ArrayList<>();
Collections.sort(list);
Collections.sort(list, Collections.reverseOrder());

List list = Arrays.asList("a", "b", "c");
Collections.reverse(list);
System.out.println(list);

List<String> list = Arrays.asList("a", "b", "c");
for (int i = 0; i < list.size() / 2; i++) {
    String temp = list.get(i);
    list.set(i, list.get(list.size() - i - 1));
    list.set(list.size() - i - 1, temp);
}
System.out.println(list);

private static void reverse(List<String> list) {
    if (list == null || list.size() <= 1) {
        return;
    }
    String value = list.remove(0);
    reverse(list);
    list.add(value);
}

public static void main(String[] args) {
    List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
    reverse(list);
    System.out.println(list);
}

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (int x : numbers) {
    sum += x;
}

// the first x is 0, the first y is 1
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(0, (x, y) -> x + y);

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(0, Integer::sum);

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer sum = numbers.stream().collect(Collectors.summingInt(Integer::intValue));

int sum = numbers.parallelStream().reduce(0, Integer::sum);

// Group employees by department
Map<Department, List<Employee>> byDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment));

// get user's roleIds
Map<Integer, Set<Integer>> userToRoleIds = userRoles.stream().collect(Collectors.groupingBy(UserRole::getUserId, Collectors.mapping(AssignmentDept::getRoleId, Collectors.toSet())));

// Partition students into passing and failing
Map<Boolean, List<Student>> passingFailing = students.stream()
    .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

// Compute sum of salaries by department
Map<Department, Integer> totalByDept = employees.stream()
    .collect(Collectors.groupingBy(Employee::getDepartment,
                                   Collectors.summingInt(Employee::getSalary)));

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer sum = numbers.stream().collect(Collectors.summingInt(Integer::intValue));

// keep sorted when group. Using `TreeMap::new` or `() -> new TreeMap<>()`
Map<String, Double> averageAgeByType = userList
    .stream()
    .collect(Collectors.groupingBy(User::getType,
                                   TreeMap::new,
                                   Collectors.averagingInt(User::getAge)));

// sort list before group and keep insertion order when group
Map<String, Double> userAverageAgeMap2 = userList
    .stream()
    .sorted(Comparator.comparing(User::getType))
    .collect(Collectors.groupingBy(User::getType,
                                   LinkedHashMap::new,
                                   Collectors.averagingInt(User::getAge)));

assumeThat("alwaysPasses", 1, is(1)); // passes
foo(); // will execute
assumeThat("alwaysFails", 0, is(1)); // assumption failure! test halts
int x = 1 / 0; // will never execute

@Test
void testNothingInParticular() throws Exception {
    Assumptions.assumingThat("DEV".equals(System.getenv("ENV")), () -> {
        assertEquals(...);
    });
}

@RunWith(SpringRunner.class) // SpringRunner is an alias for the SpringJUnit4ClassRunner.
//@RunWith(SpringJUnit4ClassRunner.class)
public class MyControllerTest {
    // ...
}

@ExtendWith(SpringExtension.class)
class MyControllerTest {
    // ...
}

@Test(expected = Exception.class)
public void testThrowsException() throws Exception {
    // ...
}

@Test
void testThrowsException() throws Exception {
    Assertions.assertThrows(Exception.class, () -> {
        //...
    });
}

@Test(timeout = 10)
public void testFailWithTimeout() throws InterruptedException {
    Thread.sleep(100);
}

@Test
void testFailWithTimeout() throws InterruptedException {
    Assertions.assertTimeout(Duration.ofMillis(10), () -> Thread.sleep(100));
}

@DisplayName("Test MyClass")
class MyClassTest {
    @Test
    @DisplayName("Verify MyClass.myMethod returns true")
    void testMyMethod() throws Exception {    
        // ...
    }
}

void assertIterableEquals(Iterable<?> expected, Iterable> actual)

void assertLinesMatch(List<String> expectedLines, List<String> actualLines)

void assertAll(Executable... executables)

<T extends Throwable> T assertThrows(Class<T> expectedType, Executable executable)

void assertDoesNotThrow (Executable executable)

@ParameterizedTest
@ValueSource(strings = {"foo", "bar"})
@NullAndEmptySource
void myParameterizedTest(String arg) {
    underTest.performAction(arg);
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyServiceTest {
    @Autowired
    private MyRepository myRepository;
    
    @org.junit.Test
    public void test(){
    }
}

@ExtendWith(SpringExtension.class)
@SpringBootTest
public class MyServiceTest {
    @Autowired
    private MyRepository myRepository;
    
    @org.junit.jupiter.api.Test
    public void test(){
    }
}

public int divide(int dividend, int divisor) {
    if (dividend == Integer.MIN_VALUE && divisor == -1) return Integer.MAX_VALUE; //Cornor case when -2^31 is divided by -1 will give 2^31 which doesnt exist so overflow

    boolean negative = dividend < 0 ^ divisor < 0; //Logical XOR will help in deciding if the results is negative only if any one of them is negative

    dividend = Math.abs(dividend);
    divisor = Math.abs(divisor);
    int quotient = 0, subQuot = 0;

    while (dividend - divisor >= 0) {
        for (subQuot = 0; dividend - (divisor << subQuot << 1) >= 0; subQuot++); 
        quotient += 1 << subQuot; //Add to the quotient
        dividend -= divisor << subQuot; //Substract from dividend to start over with the remaining
    }
    return negative ? -quotient : quotient;
}