# application.yml
database:
  url: jdbc:postgresql://localhost:5432/mydb
  username: user
  password: secret

spring.config.import=configserver:http://localhost:8888

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;

public void publishEvent(String topic, String message) {
    kafkaTemplate.send(topic, message);
}

@KafkaListener(topics = "user-events", groupId = "group_id")
public void consume(String message) {
    System.out.println("Received message: " + message);
}

public class Task251224_1 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }
}

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

public class CalculatorTest {

    @Test
    void testAddition() {
        Calculator calculator = new Calculator();
        int result = calculator.add(5, 3);
        Assertions.assertEquals(8, result, "Addition should return correct result");
    }
}

@Test
void testAddition() {
    Assertions.assertEquals(5, 2 + 3);
}

@Test
@DisplayName("Тест сложения двух чисел")
void testAddition() {
    Assertions.assertEquals(5, 2 + 3);
}

@Test
@Disabled("Тест временно отключен из-за изменений в логике")
void testDisabled() {
    Assertions.fail("Этот тест не должен выполняться");
}

@BeforeEach
void setup() {
    System.out.println("Подготовка перед тестом");
}

@AfterEach
void cleanup() {
    System.out.println("Очистка после теста");
}

@BeforeAll
static void globalSetup() {
    System.out.println("Настройка перед всеми тестами");
}

@AfterAll
static void globalCleanup() {
    System.out.println("Очистка после всех тестов");
}

public class Task261224_1 {
    public static void main(String[] args) {
        int x = 10;
        if (x > 5) {
            if (x < 15) {
                System.out.println("A");
            } else {
                System.out.println("B");
            }
        } else {
            System.out.println("C");
        }
    }
}

@Nested
class MathTests {
    @Test
    void testAddition() {
        Assertions.assertEquals(5, 2 + 3);
    }

    @Test
    void testSubtraction() {
        Assertions.assertEquals(1, 3 - 2);
    }
}

@ParameterizedTest
@ValueSource(ints = {1, 2, 3})
void testWithParameters(int value) {
    Assertions.assertTrue(value > 0);
}

@ParameterizedTest
@ValueSource(strings = {"Hello", "JUnit", "Test"})
void testStrings(String word) {
    Assertions.assertFalse(word.isEmpty());
}

@ParameterizedTest
@CsvSource({"1,2,3", "2,3,5", "3,5,8"})
void testCsvSource(int a, int b, int result) {
    Assertions.assertEquals(result, a + b);
}

enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

    @ParameterizedTest
    @EnumSource(Day.class) // Все значения перечисления Day
    void testWithEnumSource(Day day) {
        Assertions.assertNotNull(day, "Day should not be null");
    }

@ParameterizedTest
@CsvFileSource(resources = "/data.csv", numLinesToSkip = 1)
void testCsvFileSource(int a, int b, int result) {
    Assertions.assertEquals(result, a + b);
}

@Test
@EnabledOnOs(OS.WINDOWS)
void testWindowsOnly() {
    Assertions.assertTrue(System.getProperty("os.name").contains("Windows"));
}

@Test
@Timeout(5) // Тест завершится с ошибкой, если выполнится дольше 5 секунд
void testTimeout() {
    Thread.sleep(3000);
}

@TestFactory
Collection<DynamicTest> dynamicTests() {
    return Arrays.asList(
        DynamicTest.dynamicTest("1st test", () -> Assertions.assertTrue(true)),
        DynamicTest.dynamicTest("2nd test", () -> Assertions.assertEquals(4, 2 * 2))
    );
}

List<String> mockList = Mockito.mock(List.class);
Mockito.when(mockList.size()).thenReturn(10);
System.out.println(mockList.size()); // Выведет: 10

@Mock
List<String> mockList;

// Создание поведения для метода
Mockito.when(mockList.get(0)).thenReturn("Hello, Mockito!");
Mockito.when(mockList.get(1)).thenThrow(new RuntimeException("Ошибка"));

// Проверка
System.out.println(mockList.get(0)); // Выведет: Hello, Mockito!
System.out.println(mockList.get(1)); // Бросит исключение

import java.util.stream.Stream;

public class Task271224_1 {
    public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 5)
              .filter(n -> n % 2 == 0)
              .map(n -> n * 2)
              .forEach(System.out::println);
    }
}

List<String> mockList = Mockito.mock(List.class);

// Взаимодействие
mockList.add("Mockito");
mockList.clear();

// Проверка взаимодействий
Mockito.verify(mockList).add("Mockito"); // Проверяет вызов add с параметром "Mockito"
Mockito.verify(mockList).clear();       // Проверяет вызов clear

Mockito.verify(mockList, Mockito.times(1)).add("Mockito");
Mockito.verify(mockList, Mockito.never()).add("Spring");

InOrder inOrder = Mockito.inOrder(mockList);
inOrder.verify(mockList).add("Mockito");
inOrder.verify(mockList).clear();

Mockito.verifyNoInteractions(mockList);

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public String getUserName(Long id) {
        return userRepository.findById(id).orElse("Unknown");
    }
}

@ExtendWith(MockitoExtension.class)
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void getUserName_ReturnsCorrectName() {
        // Stub репозитория
        Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of("John Doe"));

        // Вызов метода
        String result = userService.getUserName(1L);

        // Проверки
        Assertions.assertEquals("John Doe", result);
        Mockito.verify(userRepository).findById(1L);
    }

    @Test
    void getUserName_ReturnsUnknownForMissingUser() {
        // Stub для случая, когда пользователь отсутствует
        Mockito.when(userRepository.findById(2L)).thenReturn(Optional.empty());

        // Вызов метода
        String result = userService.getUserName(2L);

        // Проверки
        Assertions.assertEquals("Unknown", result);
        Mockito.verify(userRepository).findById(2L);
    }
}