public class Task070125_1 {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "world";
        String result = str1.concat(" ").concat(str2).toUpperCase();
        System.out.println(result);
    }
}

@RestController
@RequestMapping("/api/items")
public class ItemController {

    private final ItemService itemService;

    @Autowired
    public ItemController(ItemService itemService) {
        this.itemService = itemService;
    }

    @GetMapping
    public List<Item> getAllItems() {
        return itemService.getAllItems();
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Item createItem(@RequestBody Item item) {
        return itemService.saveItem(item);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteItem(@PathVariable Long id) {
        itemService.deleteItem(id);
    }
}

@WebMvcTest(controllers = ItemController.class)
public class ItemControllerTest {

    @Autowired
    private MockMvc mockMvc;

   @MockitoBean
    private ItemService itemService;

    @Test
    public void testGetAllItems() throws Exception {
        List<Item> items = Arrays.asList(new Item(1L, "Item1"), new Item(2L, "Item2"));
        Mockito.when(itemService.getAllItems()).thenReturn(items);

        mockMvc.perform(get("/api/items"))
               .andExpect(status().isOk())
               .andExpect(content().contentType(MediaType.APPLICATION_JSON))
               .andExpect(jsonPath("$.size()").value(2))
               .andExpect(jsonPath("$[0].name").value("Item1"));
    }

    @Test
    public void testCreateItem() throws Exception {
        Item item = new Item(1L, "NewItem");
        Mockito.when(itemService.saveItem(Mockito.any(Item.class))).thenReturn(item);

        mockMvc.perform(post("/api/items")
                .content("{\"name\":\"NewItem\"}")
                .contentType(MediaType.APPLICATION_JSON))
               .andExpect(status().isCreated())
               .andExpect(jsonPath("$.name").value("NewItem"));
    }

    @Test
    public void testDeleteItem() throws Exception {
        mockMvc.perform(delete("/api/items/1"))
               .andExpect(status().isNoContent());
    }
}

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

spring.datasource.url=jdbc:postgresql://localhost:5432/testdb
spring.datasource.username=user
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=create-drop

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Sql(scripts = "/init-test-data.sql")
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testFindByUsername() {
        User user = userRepository.findByUsername("testuser");
        assertNotNull(user);
        assertEquals("testuser", user.getUsername());
    }
}

public class Task080125_1 {
    private static int x = 5;
    
    static {
        x = 10;
    }
    
    {
        x = 15;
    }
    
    public Task080125_1() {
        System.out.println(x);
    }
    
    public static void main(String[] args) {
        new Task080125_1();
    }
}

@Sql(scripts = "/init-test-data.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)

@Sql(scripts = "/cleanup-test-data.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)

@SpringBootTest
@Transactional
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
public class UserServiceIntegrationTest {

    @Autowired
    private UserService userService;

    @Test
    @Sql(scripts = "/init-test-data.sql")
    public void testCreateUser() {
        User user = new User();
        user.setUsername("newuser");
        user.setPassword("password");

        User savedUser = userService.createUser(user);
        assertNotNull(savedUser.getId());
        assertEquals("newuser", savedUser.getUsername());
    }
}

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>postgresql</artifactId>
    <version>1.17.6</version>
    <scope>test</scope>
</dependency>

@SpringBootTest
@Testcontainers
public class UserServiceTestcontainersTest {

    @Container
    private static final PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13");

    @DynamicPropertySource
    static void postgresProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Autowired
    private UserService userService;

    @Test
    public void testCreateUser() {
        User user = new User();
        user.setUsername("testuser");
        user.setPassword("password");

        User savedUser = userService.createUser(user);
        assertNotNull(savedUser.getId());
        assertEquals("testuser", savedUser.getUsername());
    }
}

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> asyncMethod() {
        // Имитация долгой операции
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("Done");
    }
}

@SpringBootTest
public class AsyncServiceTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    void testAsyncMethod() throws Exception {
        CountDownLatch latch = new CountDownLatch(1);
        CompletableFuture<String> future = asyncService.asyncMethod();

        future.whenComplete((result, ex) -> {
            assertThat(result).isEqualTo("Done");
            latch.countDown();
        });

        latch.await(2, TimeUnit.SECONDS); // Ожидаем завершения
        assertThat(future.isDone()).isTrue();
    }
}
Здесь CountDownLatch используется для синхронизации теста с асинхронным выполнением.

@Service
public class EventService {

    @Autowired
    private ApplicationEventPublisher publisher;

    public void publishEvent(String message) {
        publisher.publishEvent(new CustomEvent(this, message));
    }
}

public class CustomEvent extends ApplicationEvent {
    private final String message;

    public CustomEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

@SpringBootTest
public class EventServiceTest {

    @Autowired
    private EventService eventService;

    @Autowired
    private ApplicationEvents events;

    @Test
    void testEventPublication() {
        eventService.publishEvent("Test Message");

        // Проверяем, что событие было опубликовано
        assertThat(events.stream(CustomEvent.class))
            .hasSize(1)
            .first()
            .satisfies(event -> assertThat(event.getMessage()).isEqualTo("Test Message"));
    }
}

@Service
public class TransactionalService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void createUser(String name) {
        User user = new User(name);
        userRepository.save(user);
        if (name == null) {
            throw new IllegalArgumentException("Name cannot be null");
        }
    }
}

@SpringBootTest
public class TransactionalServiceTest {

    @Autowired
    private TransactionalService transactionalService;

    @Autowired
    private UserRepository userRepository;

    @Test
    void testRollback() {
        assertThatThrownBy(() -> transactionalService.createUser(null))
            .isInstanceOf(IllegalArgumentException.class);

        // Проверяем, что пользователь не был сохранен
        assertThat(userRepository.findAll()).isEmpty();
    }
}

public class Task090125_1 {
    public static void main(String[] args) {
        int i;
        for (; i < 3; i++) {
            System.out.print(i + " ");
            i = i++;
        }
    }
}

  @Test
  @Transactional
  void testSaveUser() {
      User user = new User("John Doe");
      userRepository.save(user);
      assertThat(userRepository.findAll()).hasSize(1);
  }
  

  @Test
  @Sql("/scripts/cleanup.sql")
  void testUserCreation() {
      // Тестовый код
  }
  

  @ExtendWith(MockitoExtension.class)
  public class UserServiceTest {

      @Mock
      private UserRepository userRepository;

      @InjectMocks
      private UserService userService;

      @Test
      void testFindUserById() {
          when(userRepository.findById(1L)).thenReturn(Optional.of(new User("John Doe")));
          User user = userService.findUserById(1L);
          assertThat(user.getName()).isEqualTo("John Doe");
      }
  }
  

  @SpringBootTest
  public class UserServiceIntegrationTest {

      @Autowired
      private UserService userService;

      @Test
      void testCreateUser() {
          User user = userService.createUser("Jane Doe");
          assertThat(user).isNotNull();
      }
  }
  

  @Testcontainers
  @SpringBootTest
  public class UserRepositoryTest {

      @Container
      static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13");

      @DynamicPropertySource
      static void registerPgProperties(DynamicPropertyRegistry registry) {
          registry.add("spring.datasource.url", postgres::getJdbcUrl);
          registry.add("spring.datasource.username", postgres::getUsername);
          registry.add("spring.datasource.password", postgres::getPassword);
      }

      @Test
      void testSaveUser() {
          User user = new User("John Doe");
          userRepository.save(user);
          assertThat(userRepository.findAll()).hasSize(1);
      }
  }
  

  @Test
  void testUserNotFound() {
      assertThatThrownBy(() -> userService.findUserById(999L))
          .isInstanceOf(UserNotFoundException.class);
  }
  

  @Test
  void testSendEmail() {
      EmailService emailService = mock(EmailService.class);
      UserService userService = new UserService(emailService);

      userService.notifyUser("user@example.com");

      verify(emailService).sendEmail("user@example.com");
  }
  

  @Test
  void testAsyncMethod() throws Exception {
      CountDownLatch latch = new CountDownLatch(1);
      CompletableFuture<String> future = asyncService.asyncMethod();

      future.whenComplete((result, ex) -> {
          assertThat(result).isEqualTo("Done");
          latch.countDown();
      });

      latch.await(2, TimeUnit.SECONDS);
      assertThat(future.isDone()).isTrue();
  }
  

  @Test
  void testEventPublication() {
      eventService.publishEvent("Test Message");

      assertThat(events.stream(CustomEvent.class))
          .hasSize(1)
          .first()
          .satisfies(event -> assertThat(event.getMessage()).isEqualTo("Test Message"));
  }
  

public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class User {
    private String name;
    private int age;
}
Lombok убирает необходимость писать шаблонный код, что особенно полезно в больших проектах.

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.36</version>
    <scope>provided</scope>
</dependency>

dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.36'
    annotationProcessor 'org.projectlombok:lombok:1.18.36'
}

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class User {
    private String name;
    private int age;
}

@Getter(AccessLevel.PROTECTED)
private String name;

import lombok.ToString;

@ToString
public class User {
    private String name;
    private int age;
}

@Override
public String toString() {
    return "User(name=" + this.name + ", age=" + this.age + ")";
}

@ToString(exclude = "age")
public class User {
    private String name;
    private int age;
}

@ToString(of = "name")
public class User {
    private String name;
    private int age;
}

public class Task1001245_1 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = new String("hello");
        String s3 = "hello";
        String s4 = s2.intern();

        System.out.println((s1 == s2) + " " + (s1 == s3) + " " + (s1 == s4));
    }
}