package com.xxxxx.xxxxx.xxx.config;

import org.hibernate.dialect.MySQL57Dialect;
import org.hibernate.dialect.function.StandardSQLFunction;
import org.hibernate.type.StandardBasicTypes;

public class CustomMySQLDialect extends MySQL57Dialect {
    public CustomMySQLDialect() {
        super();
        // JPA QueryDSL에서 group_concat 함수를 사용할 수 있도록 등록
        registerFunction("group_concat", new StandardSQLFunction("group_concat", StandardBasicTypes.STRING));
    }
}

@Repository
@RequiredArgsConstructor
public class QClassAccessCntrlHistRepository implements ExAccessCntrlHistRepository { 
    private final JPAQueryFactory jpaQueryFactory;

    @Override
    public List<ResAccessCntrlHistVO> getAccessCntrlList(ReqAccessCntrlHistSearchVO searchVO) {
        QAccessCntrlHist qAccessCntrlHist = QAccessCntrlHist.accessCntrlHist;
        QGateInfo qGateInfo = QGateInfo.gateInfo;
        QUsr qUsr = QUsr.usr;
        QQuestnAnsr qQuestnAnsr = QQuestnAnsr.questnAnsr1;
      
        Pageable pageable = PageRequest.of(searchVO.getStart(), searchVO.getLength()); // Pageable로 만들어주기 위함
      
        return jpaQueryFactory
                .select(
                        Projections.fields(
                                ResAccessCntrlHistVO.class,
                                qAccessCntrlHist.accessCntrlHistSn,
                                qAccessCntrlHist.accessCntrlRegDt,
                                qUsr.usrCameraId,
                                qGateInfo.gateNm,
                                qAccessCntrlHist.img,
                                qUsr.nm,
                                qUsr.mbtlno,
                                qUsr.usrTy,
                                qUsr.mngGradeTy,
                                qAccessCntrlHist.tempr,
                                qAccessCntrlHist.temprStts,
                                qAccessCntrlHist.accessCntrlTy,
                                Expressions.stringTemplate("group_concat({0})", qQuestnAnsr.questnAnsr).as("questnAnsr"),
                                qQuestnAnsr.nm.max().as("qNm"),
                                qQuestnAnsr.mbtlno.max().as("qMbtlno")
                        )
                )
                .from(qAccessCntrlHist)
                .leftJoin(qUsr)
                .on(qAccessCntrlHist.usrSn.eq(qUsr.usrSn))
                .leftJoin(qGateInfo)
                .on(qAccessCntrlHist.gateInfoSn.eq(qGateInfo.gateInfoSn))
                .leftJoin(qQuestnAnsr)
                .on(qAccessCntrlHist.questnAnsrId.eq(qQuestnAnsr.questnAnsrId))
                .where(
                        eqGateInfoSn(searchVO.getGateInfoSn()),
                        betWeenStrAccessCntrlRegDt(searchVO.getSchStrDt(), searchVO.getSchEndDt()),
                        eqAccessCntrlTy(searchVO.getAccessCntrlTy()),
                        likeSearchKeyword(searchVO.getSearchKeyword())
                )
                .groupBy(qAccessCntrlHist.accessCntrlHistSn, qUsr.nm, qQuestnAnsr.nm, qUsr.mbtlno, qQuestnAnsr.mbtlno)
                .orderBy(qAccessCntrlHist.accessCntrlRegDt.desc())
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize())
                .fetch();
    }
}

import static org.assertj.core.api.Assertions.assertThat;

class AssertionsTest {
    @Test
    void assertions_테스트() {
        String str1 = "문자열";
        String str2 = "문자열";
        System.out.println("str1 = " + str1.hashCode());
        System.out.println("str2 = " + str2.hashCode());

        Assertions.assertEquals(str1, str2);
    }
}

import static org.assertj.core.api.Assertions.*;

public class AssertJTest {

    @Test
    void assertj_테스트() {
        String str1 = "문자열";
        String str2 = "문자열";
        System.out.println("str1 = " + str1.hashCode());
        System.out.println("str2 = " + str2.hashCode());

        assertThat(str1).isEqualTo(str2);
    }
}

class CollectionTest {

    @Test
    public void junit_assertions_테스트() {
        ArrayList<Student> characters = new ArrayList<>();
        Student spring = new Student("Spring");
        Student jpa = new Student("Jpa");
        Student kubernetes = new Student("Kubernetes");
        characters.add(spring);
        characters.add(jpa);
        characters.add(kubernetes);

        List<Student> expected = new ArrayList<>();
        expected.add(spring);
        expected.add(jpa);
        List<Student> filteredList = characters.stream()
                .filter((character) -> character.name.contains("p"))
                .collect(Collectors.toList());

        Assertions.assertEquals(expected,filteredList);
    }

    static class Student {
        private String name;
        public Student(String name) { this.name = name; }
    }
}

class CollectionTest {

    @Test
    public void assertj_테스트() {
        ArrayList<Student> characters = new ArrayList<>();
        Student spring = new Student("Spring");
        Student jpa = new Student("Jpa");
        Student kubernetes = new Student("Kubernetes");

        characters.add(spring);
        characters.add(jpa);
        characters.add(kubernetes);

        assertThat(characters)
                .filteredOn(character -> character.name.contains("p"))
                .containsOnly(spring, jpa);
    }

    static class Student {
        private String name;
        public Student(String name) { this.name = name; }
    }
}

import static org.assertj.core.api.Assertions.assertThat;

class JUnitTest {
    @Test
    void 기본_테스트_메서드() {
        // isEqualTo()
        String str1 = new String("hello");
        String str2 = new String("hello");
        assertThat(str1).isEqualTo(str2); // 비교 대상의 내용이 같은지 확인
        // isSameAs()
        String str3 = str1;
        assertThat(str1).isSameAs(str3); // 같은 객체를 참조하고 있는지 확인

        // isNotNull()
        assertThat(str1).isNotNull(); // 객체가 null이 아닌지 확인

        // isNull()
        String str4 = null;
        assertThat(str4).isNull(); // 객체가 null인지 확인

        // isNotEmpty() and isEmpty()
        List<String> emptyList = new ArrayList<>();
        List<String> nonEmptyList = Arrays.asList("apple", "banana");
        assertThat(emptyList).isEmpty(); // 비어있는지 확인
        assertThat(nonEmptyList).isNotEmpty(); // 비어있지 않은지 확인

        // isIn() and isNotIn()
        String fruit1 = "apple";
        String fruit2 = "orange";
        assertThat(fruit1).isIn(nonEmptyList); // "apple"이 리스트에 포함되어 있는지 확인
        assertThat(fruit2).isNotIn(nonEmptyList); // "orange"가 리스트에 포함되어 있지 않은지 확인
    }
}

import static org.assertj.core.api.Assertions.*;

public class AssertJTest {

    @Test
    void 문자열_테스트() {
        assertThat("Hello, world! Nice to meet you.") // 주어진 "Hello, world! Nice to meet you."라는 문자열은
                .isNotEmpty() // 비어있지 않고
                .contains("Nice") // "Nice"를 포함하고
                .contains("world") // "world"도 포함하고
                .doesNotContain("ZZZ") // "ZZZ"는 포함하지 않으며
                .startsWith("Hell") // "Hell"로 시작하고
                .endsWith("u.") // "u."로 끝나며
                .isEqualTo("Hello, world! Nice to meet you."); // "Hello, world! Nice to meet you."과 일치
    }
}

import static org.assertj.core.api.Assertions.*;

public class AssertJTest {

    @Test
    void 숫자_테스트() {
        assertThat(3.14d) // 주어진 3.14라는 숫자는
                .isPositive() // 양수이고
                .isGreaterThan(3) // 3보다 크며
                .isLessThan(4) // 4보다 작습니다
                .isEqualTo(3, offset(1d)) // 오프셋 1 기준으로 3과 같고
                .isEqualTo(3.1, offset(0.1d)) // 오프셋 0.1 기준으로 3.1과 같으며
                .isEqualTo(3.14); // 오프셋 없이는 3.14와 같습니다
    }
}

import static org.assertj.core.api.Assertions.*;

class FailMessageTest {
    
    @Test
    void fail_message_테스트() {
        String str = "JUnit";
        assertThat(str)
                // as는 검증 문보다 앞에 작성해야 하며, 그렇지 않을 경우 검증 문 이후 호출이 중단됨으로 무시된다.
                .as("기대값(Expected) AssertJ와 실제값(Actual) %s이 일치하지 않습니다.", str)
                .isEqualTo("AssertJ");
    }
}

import static org.assertj.core.api.Assertions.*;

class FilteredOnTest {
    public Member member1, member2, member3;
    public List<Member> members;

    static class Member {
        private String name;
        private int age;
        private MemberRole role;

        public Member(String name, int age, MemberRole role) {
            this.name = name;
            this.age = age;
            this.role = role;
        }

        public String getName() { return name; }
        public int getAge() {return age; }
        public MemberRole getRole() { return role; }
    }

    enum MemberRole { ADMIN, BASIC, VIP }

    @BeforeEach
    public void createMember() {
        member1 = new Member("Kim", 20, MemberRole.ADMIN);
        member2 = new Member("Ahn", 20, MemberRole.BASIC);
        member3 = new Member("Park", 21, MemberRole.VIP);
        members = Lists.list(member1, member2, member3);
    }

    @Test
    public void 체이닝_람다를_사용한_필터_테스트() {
        assertThat(members) // members 컬렉션에서
                .filteredOn(member -> member.getAge() >= 20) // age >= 20 인 객체만 필터링
                .filteredOn(member -> !member.getName().equals("Kim")) // name이 "Kim"과 같지 않은 객체만 필터링
                .filteredOn("role", in(MemberRole.VIP)) // "role"이 MemberRole.VIP인 객체를 필터링
                .containsOnly(member3) // 그 객체가 오직 member3 이며,
                .isNotEmpty(); // 비어있지 않다.
    }
}

import static org.assertj.core.api.Assertions.*;

class FilteredOnTest {
    public Member member1, member2, member3;
    public List<Member> members;

    class Member {
        private String name;
        private int age;
        private MemberRole role;

        public Member(String name, int age, MemberRole role) {
            this.name = name;
            this.age = age;
            this.role = role;
        }

        public String getName() { return name; }
        public int getAge() {return age; }
        public MemberRole getRole() { return role; }
    }

    enum MemberRole { ADMIN, BASIC, VIP }

    @BeforeEach
    public void createMember() {
        member1 = new Member("Kim", 20, MemberRole.ADMIN);
        member2 = new Member("Ahn", 20, MemberRole.BASIC);
        member3 = new Member("Park", 21, MemberRole.VIP);
        members = Lists.list(member1, member2, member3);
    }

    @Test
    public void 메서드_레퍼런스를_이용한_필터_테스트() {
        assertThat(members) // members 컬렉션에서
                .filteredOn(
                        member -> member.getAge() >= 20 // member 객체의 age가 >= 20 인 객체만 필터링
                                && !member.getName().equals("Kim") // member 객체의 name이 "Kim"과 같지 않은 객체만 필터링
                                && member.getRole().equals(MemberRole.VIP) // member 객체의 role이 MemberRole.VIP인 객체를 필터링
                )
                .extracting(
                        Member::getName, // member -> member.getName() => Member 클래스 객체의 getName() 메서드를 참조
                        Member::getAge, // member -> member.getAge()
                        Member::getRole // member -> member.getRole()
                )
                .containsExactly(tuple("Park", 21, MemberRole.VIP)); // containsExactly(): 순서 원소의 개수와 값이 일치해야 한다.
    }
}

import static org.assertj.core.api.Assertions.assertThatThrownBy;

class AssertThrowsTest {

    @Test
    void assertThrows_테스트() {
        // given
        String input = "abc";

        // when, then : 입력값 범위 밖일 경우 StringIndexOutOfBoundsException 발생
        assertThatThrownBy(() -> input.charAt(input.length()))
                .isInstanceOf(StringIndexOutOfBoundsException.class)
                .hasMessageContaining("String index out of length");
    }
}

import static org.assertj.core.api.Assertions.assertThatThrownBy;

class AssertThrowsTest {

    @Test
    void assertThrows_테스트() {
        // given
        String input = "abc";

        // when, then : 입력값 범위 밖일 경우 StringIndexOutOfBoundsException 발생
        assertThatThrownBy(() -> input.charAt(input.length()))
                .isInstanceOf(StringIndexOutOfBoundsException.class)
                .hasMessageContaining(String.valueOf(4));
    }
}

import static org.assertj.core.api.Assertions.assertThatThrownBy;

class AssertThrowsTest {

    @Test
    void assertThrows_테스트() {
        // given
        String input = "abc";

        // when, then : 입력값 범위 밖일 경우 StringIndexOutOfBoundsException 발생
        assertThatThrownBy(() -> input.charAt(input.length()))
                .isInstanceOf(StringIndexOutOfBoundsException.class)
                .hasMessageContaining("String index out of range")
                .hasMessageContaining(String.valueOf(input.length()));
    }
}

class DisabledExampleTest {
    
    @Test
    @Disabled("문제가 해결될 때까지 테스트 중단")
    void 테스트1() {
        System.out.println("테스트1");
    }
    
    @Test
    void 테스트2() {
        System.out.println("테스트2");
    }
}

public class NestedExampleTest {

    @Nested
    class 중첩_클래스_1 {
        @Test
        public void 성공() { }

        @Test
        public void 실패() { }
    }

    @Nested
    class 중첩_클래스_2 {

        @Nested
        class 테스트1 {
            @Test
            public void 성공() { }

            @Test
            public void 실패() { }
        }

        @Nested
        class 테스트2 {
            @Test
            public void 성공() { }

            @Test
            public void 실패() { }
        }
    }
}

class TagExampleTest {

    @Test
    @Tag("top")
    void top_line() { }

    @Test
    @Tag("jungle")
    void jungle_line() { }

    @Test
    @Tag("mid")
    void mid_line() { }

    @Test
    @Tag("ad")
    void ad_line() { }

    @Test
    @Tag("support")
    void support_line() { }
}

@Retention(RetentionPolicy.RUNTIME) // 해당 어노테이션이 붙은 메서드가 런타임 될 동안까지 실행
@Target(value = {ElementType.TYPE, ElementType.METHOD}) // 메서드에서 사용할 것이이라고 지정
@Tag("TopLine")
public @interface TopLine {
}

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE, ElementType.METHOD})
@Tag("JungleLine")
public @interface JungleLine { }

@Retention(RetentionPolicy.RUNTIME) 
@Target(value = {ElementType.TYPE, ElementType.METHOD})
@Tag("MidLine")
public @interface MidLine { }

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE, ElementType.METHOD})
@Tag("AdLine")
public @interface AdLine { }

@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE, ElementType.METHOD})
@Tag("SupportLine")
public @interface SupportLine { }

class TagExampleTest {

    @Test
    @TopLine
    void top_line() { }

    @Test
    @JungleLine
    void jungle_line() { }

    @Test
    @MidLine
    void mid_line() { }

    @Test
    @AdLine
    void ad_line() { }

    @Test
    @SupportLine
    void support_line() { }
}

class TimeoutExampleTest {

    @BeforeEach
    @Timeout(5)
    void setUp() {
        // 실행 시간이 5초를 초과하면 실패
    }

    @Test
    @Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
    void failsIfExecutionTimeExceeds500Milliseconds() {
        // 실행 시간이 500밀리초(0.5초)를 초과하면 실패
    }

    @Test
    @Timeout(value = 500, unit = TimeUnit.MILLISECONDS, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
    void failsIfExecutionTimeExceeds500MillisecondsInSeparateThread() {
        // 실행 시간이 500밀리초(0.5초)를 초과하면 실패하고 테스트 코드가 별도의 스레드에서 실행된다.
    }
}

class TimeoutExampleTest {

    @BeforeAll
    static void testBeforeAll() {
        System.out.println("BeforeAll");
    }
    
    @AfterAll
    static void testAfterAll() {
        System.out.println("AfterAll");
    }
    
    @Timeout(1) // 1초 지나면 테스트 실패
    @Test
    void timeoutException() throws InterruptedException {
        System.out.println("timeoutException");
        assertEquals("timeout", "timeout");
        Thread.sleep(2000); // 2초동안 스레드 sleep
    }
}

@ExtendWith(SpringExtension.class)
class ExtendWithExampleTest { }

@ExtendWith(MockitoExtension.class)
class ExtendWithExampleTest { }

public class ExtensionExample implements BeforeEachCallback, AfterEachCallback {
    @Override
    public void beforeEach(final ExtensionContext context) throws Exception {
        System.out.println("ExtensionExample.beforeEach");
    }

    @Override
    public void afterEach(final ExtensionContext context) throws Exception {
        System.out.println("ExtensionExample.afterEach");
    }
}

@ExtendWith(ExtensionExample.class)
class ExtensionExampleTest {
    @Test
    void test1() {
        System.out.println("  test1()");
    }

    @Test
    void test2() {
        System.out.println("  test2()");
    }
}

// @ExtendWith(ExtensionExample.class)
class ExtensionExampleTest {
    
    @Test
    @ExtendWith(ExtensionExample.class)
    void test1() {
        System.out.println("  test1()");
    }

    @Test
    void test2() {
        System.out.println("  test2()");
    }
}

public class RegisterExtensionExample implements BeforeEachCallback, BeforeAllCallback {
    private final String name;

    public RegisterExtensionExample(final String name) { this.name = name; }

    @Override
    public void beforeAll(final ExtensionContext context) throws Exception {
        System.out.println("[" + this.name + "] beforeAll()");
    }

    @Override
    public void beforeEach(final ExtensionContext context) throws Exception {
        System.out.println("[" + this.name + "] beforeEach()");
    }
}

public class RegisterExtensionExampleTest {

    @RegisterExtension
    static RegisterExtensionExample classField = new RegisterExtensionExample("classField");

    @RegisterExtension
    RegisterExtensionExample instanceField = new RegisterExtensionExample("instanceField");

    @BeforeAll
    static void beforeAll() { System.out.println("beforeAll()"); }

    @BeforeEach
    void beforeEach() { System.out.println("beforeEach()"); }

    @Test
    void test1() { System.out.println("test1()"); }
}

class TempDirExampleTest {
    @TempDir
    File tempFolderFile;

    @Test
    void test1() {
        System.out.println(tempFolderFile.getAbsolutePath());
    }

    @Test
    void test2(@TempDir Path tempFolderPath) {
        System.out.println(tempFolderFile.getAbsolutePath());
    }
}

public class TestTemplateTest {
    final List<String> fruits = Arrays.asList("apple", "banana", "lemon");

    @TestTemplate
    @ExtendWith(MyTestTemplateInvocationContextProvider.class)
    void testTemplate(String fruit) {
        assertTrue(fruits.contains(fruit));
    }

    public class MyTestTemplateInvocationContextProvider implements TestTemplateInvocationContextProvider {
        @Override
        public boolean supportsTestTemplate(ExtensionContext context) { return true; }

        @Override
        public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContexts(ExtensionContext context) {
            return Stream.of(invocationContext("apple"), invocationContext("banana"));
        }

        private TestTemplateInvocationContext invocationContext(String parameter) {
            return new TestTemplateInvocationContext() {
                @Override
                public String getDisplayName(int invocationIndex) { return parameter; }

                @Override
                public List<Extension> getAdditionalExtensions() {
                    return Collections.singletonList(new ParameterResolver() {
                        @Override
                        public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
                            return parameterContext.getParameter().getType().equals(String.class);
                        }

                        @Override
                        public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) {
                            return parameter;
                        }
                    });
                }
            };
        }
    }

    @Test
    void testTemplateTest() {
        testTemplate("apple");
    }
}

@TestClassOrder(ClassOrderer.OrderAnnotation.class)
class TestClassOrderExampleTest {
    @Nested
    @Order(1)
    class PrimaryTests {
        @Test
        void test1() {}
    }

    @Nested
    @Order(2)
    class SecondaryTests {
        @Test
        void test2() {}
    }
}

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class TestMethodOrderExampleTest {
    @Test
    @Order(1)
    void test1() {}

    @Test
    @Order(2)
    void test2() {}

    @Test
    @Order(3)
    void test3() {}
}

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class TestMethodOrderExampleTest {
    @Test
    @Order(2)
    void test1() {}

    @Test
    @Order(3)
    void test2() {}

    @Test
    @Order(1)
    void test3() {}
}

class TestInstanceExampleTest {
    int number = 0;

    @Test
    void add1() {
        number++;
        System.out.println("add1() number = " + number);
        System.out.println(this);
    }

    @Test
    void add2() {
        number += 2;
        System.out.println("add2() number = " + number);
        System.out.println(this);
    }
}

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class TestInstanceExampleTest {
    int number = 0;

    @Test
    void add1() {
        number++;
        System.out.println("add1() number = " + number);
        System.out.println(this);
    }

    @Test
    void add2() {
        number += 2;
        System.out.println("add2() number = " + number);
        System.out.println(this);
    }
}

public class TestFactoryExample {
    private final Calculator calculator = new Calculator();

    // JUnitException 발생
    @TestFactory // @TestFactory 어노테이션을 사용할 때,@TestFactory
    List<String> dynamicTestsWithInvalidReturnType() {
        return Arrays.asList("Hello");
    }
    
    @TestFactory // Collection<DynamicTest>를 반환하는 @TestFactory
    Collection<DynamicTest> dynamicTestsFromCollection() {
        return Arrays.asList(
                dynamicTest("1st dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("2nd dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        );
    }

    @TestFactory // Iterable<DynamicTest>를 반환하고, Arrays.asList()를 사용하여 테스트 케이스를 생성
    Iterable<DynamicTest> dynamicTestsFromIterable() {
        return Arrays.asList(
                dynamicTest("3rd dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("4th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        );
    }

    @TestFactory // Iterator<DynamicTest>를 반환하며, Arrays.asList().iterator()를 사용하여 테스트 케이스를 생성
    Iterator<DynamicTest> dynamicTestsFromIterator() {
        return Arrays.asList(
                dynamicTest("5th dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("6th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        ).iterator();
    }

    @TestFactory // DynamicTest[]를 반환하고, 테스트 케이스를 배열로 생성
    DynamicTest[] dynamicTestsFromArray() {
        return new DynamicTest[] {
                dynamicTest("7th dynamic test", () -> assertTrue(isPalindrome("madam"))),
                dynamicTest("8th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2)))
        };
    }

    @TestFactory // 특정 문자열에 대해 isPalindrome 검사를 수행하는 동적 테스트를 반환하는 Stream<DynamicTest>를 생성
    Stream<DynamicTest> dynamicTestsFromStream() {
        return Stream.of("racecar", "radar", "mom", "dad")
                .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text))));
    }

    @TestFactory // 처음 10개의 짝수 정수에 대한 동적 테스트를 생성하는 Stream<DynamicTest>를 반환
    Stream<DynamicTest> dynamicTestsFromIntStream() {
        // 처음 10개의 짝수 정수에 대한 테스트를 생성
        return IntStream.iterate(0, n -> n + 2)
                .limit(10)
                .mapToObj(n -> dynamicTest("test" + n, () -> assertTrue(n % 2 == 0)));
    }

    @TestFactory // 무작위로 생성된 정수들에 대해 동적 테스트를 생성하는 Stream<DynamicTest>를 반환
    Stream<DynamicTest> generateRandomNumberOfTestsFromIterator() {
        // 0에서 100 사이의 임의의 양의 정수를 생성
        // 7로 균등하게 나누어지는 숫자를 만듦
        Iterator<Integer> inputGenerator = new Iterator<Integer>() {
            Random random = new Random();
            int current;

            @Override
            public boolean hasNext() {
                current = random.nextInt(100);
                return current % 7 != 0;
            }

            @Override
            public Integer next() {
                return current;
            }
        };

        // 입력:5, 입력:37, 입력:85 등과 같은 표시 이름을 생성
        Function<Integer, String> displayNameGenerator = (input) -> "input:" + input;

        // 현재 입력 값을 기준으로 테스트를 실행
        ThrowingConsumer<Integer> testExecutor = (input) -> assertTrue(input % 7 != 0);

        // 동적 테스트 스트림을 반환
        return DynamicTest.stream(inputGenerator, displayNameGenerator, testExecutor);
    }

    @TestFactory // 주어진 문자열이 회문인지 확인하는 동적 테스트를 반환하는 Stream<DynamicTest>를 생성
    Stream<DynamicTest> dynamicTestsFromStreamFactoryMethod() {
        // 확인 할 회문(e.g) 기러기, 토마토, 등등)을 Stream으로 저장 
        Stream<String> inputStream = Stream.of("racecar", "radar", "mom", "dad");

        // 다음과 같은 표시 이름 생성 : racecar는 회문(e.g) 기러기, 토마토, 등등)이다
        Function<String, String> displayNameGenerator = text -> text + " is a palindrome";

        // 현재 입력 값을 기준으로 테스트를 실행
        ThrowingConsumer<String> testExecutor = text -> assertTrue(isPalindrome(text));

        // 동적 테스트 스트림을 반환
        return DynamicTest.stream(inputStream, displayNameGenerator, testExecutor);
    }

    @TestFactory // 이름이 지정된 동적 테스트를 반환하는 Stream<DynamicTest>를 생성
    Stream<DynamicTest> dynamicTestsFromStreamFactoryMethodWithNames() {
        // 확인 할 회문(e.g) 기러기, 토마토, 등등)을 Stream으로 저장
        Stream<Named<String>> inputStream = Stream.of(
                named("racecar is a palindrome", "racecar"),
                named("radar is also a palindrome", "radar"),
                named("mom also seems to be a palindrome", "mom"),
                named("dad is yet another palindrome", "dad")
        );

        // 동적 테스트 스트림을 반환
        return DynamicTest.stream(inputStream, text -> assertTrue(isPalindrome(text)));
    }

    @TestFactory // DynamicNode를 반환하는 동적 테스트를 생성
    Stream<DynamicNode> dynamicTestsWithContainers() {
        // 여기서는 "A", "B", "C" 에 대한 동적 컨테이너를 생성하며, 이 컨테이너 안에는 문자열 관련 성질을 검사하는 다른 동적 테스트들이 포함
        return Stream.of("A", "B", "C")
                .map(input -> dynamicContainer("Container " + input, Stream.of(
                        dynamicTest("not null", () -> assertNotNull(input)),
                        dynamicContainer("properties", Stream.of(
                                dynamicTest("length > 0", () -> assertTrue(input.length() > 0)),
                                dynamicTest("not empty", () -> assertFalse(input.isEmpty()))
                        ))
                )));
    }

    @TestFactory // 단일 동적 테스트 DynamicNode를 반환하며, "pop" 문자열이 회문(e.g) 기러기, 토마토, 등등)인지 확인
    DynamicNode dynamicNodeSingleTest() {
        return dynamicTest("'pop' is a palindrome", () -> assertTrue(isPalindrome("pop")));
    }

    @TestFactory // 하나의 동적 컨테이너 DynamicNode를 반환하며, 다양한 문자열에 대해 회문 검사하는 동적 테스트들이 포함
    DynamicNode dynamicNodeSingleContainer() {
        return dynamicContainer("palindromes",
                Stream.of("racecar", "radar", "mom", "dad")
                        .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text)))));
    }

    // 주어진 문자열이 회문인지 확인하는 로직을 구현한 것입니다. 단어가 거꾸로 읽어도 동일한 문자열인 경우, 회문으로 판단
    private static boolean isPalindrome(String str) {
        // 원래 str의 역순을 저장하기 위해 빈 문자열 초기화
        String rev = "";

        // 답변에 대한 새 boolean 변수 초기화
        boolean ans = false;
        // 역순으로 문자열 저장
        for (int i = str.length() - 1; i >= 0; i--) {
            rev = rev + str.charAt(i);
        }
        // 두 문자열이 같은지 확인
        if (str.equals(rev)) {
            ans = true;
        }
        return ans;
    } 
    
}

// file: 풀이.java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
  public static void main(String[] args) throws IOException {
    
    // 1) 첫 번째 방법
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    char[][] words = new char[5][15]; // 문자 하나씩 저장하기 위한 이중 배열 선언

    // 다섯 줄의 단어(word)를 입력 받아 words 배열에 담음
    for (int i = 0; i < 5; i++) { // 5번 반복
      String word = br.readLine();
      for (int j = 0; j < word.length(); j++) { // 입력한 값의 개수만큼 반복
        // charAt() 해당 인덱스의 값을 반환해줌
        words[i][j] = word.charAt(j); // words i번째 j번 방에 입력한 문자열 word 변수의 j번째 값 넣기
      }
    }

    // 세로로 읽어들인 문자들을 출력함
    // String이 아닌 StringBuilder를 사용한 이유?
    // String의 경우 기존에 선언한 값에 추가(+=)한 경우 새로운 객체로 탄생하게 된다.
    // 하지만, StringBuilder의 경우 sb.append("xxx") 새로운 값을 추가하게 되면 기존 StringBuilder의 객체에 새로운 값이 추가된다.
    StringBuilder sb = new StringBuilder();
    for (int j = 0; j < 15; j++) {
      for (int i = 0; i < 5; i++) {
        if (words[i][j] != '\0') { // \0은 널 문자(Null character)를 나타낸다. 즉, null이 아닐때
          sb.append(words[i][j]); // 횡(row)로 append해주기
        }
      }
    }
    System.out.println(sb);
    
    // -------------------------------------------------------------

    // 2) 두 번째 Stream API를 이용한 방법
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // BufferedReader를 사용하여 입력을 처리
    String[] words = new String[5]; // 문자열 배열 words를 선언

    for (int i = 0; i < 5; i++) { // 반복문을 사용하여 5개의 문자열을 입력 받고, words 배열에 저장
      words[i] = br.readLine();
    }

    String result = IntStream.range(0, 15) // IntStream을 사용하여 0부터 14까지의 범위를 생성. 이 숫자들은 문자열의 인덱스를 나타낸다.
            // .mapToObj()를 사용하여 각 인덱스에 대해 아래의 연산을 수행
            .mapToObj(j -> IntStream.range(0, 5) // 내부적으로 또 다른 IntStream을 생성하여 0부터 4까지의 범위를 나타낸다. 이 숫자들은 각 문자열의 인덱스이다
                    .filter(i -> j < words[i].length()) // .filter()를 사용하여 해당 인덱스에 문자가 있는지 확인하고, 필요한 경우 해당 문자열에서 문자를 가져온다.
                    .mapToObj(i -> words[i].charAt(j)) // .mapToObj()를 사용하여 문자를 문자 객체로 변환
                    .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append).toString()) // .collect()를 사용하여 내부 인덱스(IntStream의 요소)에 대해 필터링된 문자를 차례대로 StringBuilder 객체에 추가
            .collect(Collectors.joining()); // .collect(Collectors.joining())을 사용하여 각 인덱스의 문자들을 모아 하나의 문자열로 만든다.

    System.out.println(result);
  }
}

class JUnitTest() {
    // JUnit4
    @Test(exptected = Exception.class)
    public void 상품주문() throws Exception {
        // ...
    }
    
    // JUnit5
    @Test
    void 상품주문() {
        // ...
    }
}

public class DisplayNameTest {
    
    @Test
    void 기본() {
    }
    
    @DisplayName("한글 메서드")
    @Test
    void 한글() {
    }
    
    @DisplayName("english")
    @Test
    void english() {
    }
    
    @DisplayName("특수문자 \uD83D\uDE00")
    @Test
    void 특수문자() {
    }
}

public class DisplayNameGenerationTest {
    @Nested
    @DisplayNameGeneration(DisplayNameGenerator.IndicativeSentences.class) // inner class, 메서드명 출력
    class IndicativeSentences {
        @Test
        void test_display_name_generation() {
        }
    }

    @Nested
    @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class) // _(underscore) 를 공백으로 바꿈
    class ReplaceUnderscores {
        @Test
        void test_display_name_generation() {
        }
    }

    @Nested
    @DisplayNameGeneration(DisplayNameGenerator.Simple.class) // 괄호()를 제외 
    class Simple {
        @Test
        void test_display_name_generation() {
        }
    }

    @Nested
    @DisplayNameGeneration(DisplayNameGenerator.Standard.class) // 기본값. 메서드 이름 그대로 출력
    class Standard {
        @Test
        void test_display_name_generation() {
        }
    }
}

class ParameterizedTestTest {

    private Set<Integer> numbers;

    @BeforeEach
    void setup() {
        numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
    }

    @DisplayName("일반_반복테스트")
    @Test
    void 일반_반복테스트() {
        assertThat(numbers.contains(1)).isTrue();
        assertThat(numbers.contains(2)).isTrue();
        assertThat(numbers.contains(3)).isTrue();
        for (int num : numbers) {
            System.out.println("일반 반복 테스트 : " + num);
        }
    }

    @DisplayName("반복_테스트")
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3})
    void 반복_테스트(int intArg) {
        assertThat(numbers.contains(intArg)).isTrue();
    }
}

public class CvsSourceTest {
    @ParameterizedTest
    @CsvSource({ "apple, banana" })
    void cvsSourceTest1(String fruit1, String fruit2) {
    }

    @ParameterizedTest
    @CsvSource({ "apple, 'lemon, lime'" })
    void cvsSourceTest2(String fruit1, String fruit2) {
    }

    @ParameterizedTest
    @CsvSource({ "apple, ''" })
    void cvsSourceTest3(String fruit1, String fruit2) {
    }

    @ParameterizedTest
    @CsvSource({ "apple, " })
    void cvsSourceTest4(String fruit1, String fruit2) {
    }

    @ParameterizedTest
    @CsvSource(value = { "apple, banana, NIL" }, nullValues = "NIL")
    void cvsSourceTest5(String fruit1, String fruit2) {
    }
}

public class RepeatTest {
    @RepeatedTest(5)
    @DisplayName("반복 테스트1")
    void repeatedTest1() {
    }

    @RepeatedTest(value = 5, name = "반복테스트2 중 {currentRepetition} of {totalRepetitions}")
    @DisplayName("반복 테스트2")
    void repeatedTest2() {
    }
}

class JUnit5LifeCycleTest {

    @BeforeAll
    static void setup() {
        System.out.println("@BeforeAll - executes once before all test methods in this class");
    }
  
    @BeforeEach
    void init() {
        System.out.println("@BeforeEach - executes before each test method in this class");
    }
  
    @AfterEach
    void tearDown() {
        System.out.println("@AfterEach - executed after each test method.");
    }
  
    @AfterAll
    static void tearDownAll() {
        System.out.println("@AfterAll - executed after all test methods.");
    }
  
    @Test
    void successTest1() {
        System.out.println("executes successTest1");
        assumeTrue("abc".contains("a"));
    }
  
    @Test
    void successTest2() {
        System.out.println("executes successTest2");
        assumeTrue("abc".contains("b"));
    }
    
    // 출력 ---------------------------------------------------------
    /*
      @BeforeAll - executes once before all test methods in this class
      @BeforeEach - executes before each test method in this class
      executes successTest1
      @AfterEach - executed after each test method.
      @BeforeEach - executes before each test method in this class
      executes successTest2
      @AfterEach - executed after each test method.
      @AfterAll - executed after all test methods.
    */
}

// file: 풀이.java
import java.util.Scanner;

public class Main {
  public static void main(String[] args) throws IOException {
    Scanner sc = new Scanner(System.in);

    int N = sc.nextInt();   // 정수 N
    int X = sc.nextInt();   // 정수 X

    int[] A = new int[N];   // 정수 N으로 이루어진 수열(배열) A

    // 정수 N개로 이루어진 수열 A의 조건을 만족하기 위한 반복문
    for (int i = 0; i < N; i++) {
      A[i] = sc.nextInt();
      if (A[i] < X) {
        System.out.print(A[i] + " ");
      }
    }
    sc.close(); // 스캐너 close
  }
}