@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));
    }
}

import lombok.EqualsAndHashCode;

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

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    User user = (User) o;
    return age == user.age && Objects.equals(name, user.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

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

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

import lombok.NoArgsConstructor;

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

@NoArgsConstructor(force = true)
public class User {
    private final String name = null; // final-поле будет инициализировано как null
    private int age;
}

import lombok.AllArgsConstructor;

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

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

// Использование:
User user = User.of("John", 30);

import lombok.RequiredArgsConstructor;
import lombok.NonNull;

@RequiredArgsConstructor
public class User {
    @NonNull
    private final String name;
    private int age;
}

public User(@NonNull String name) {
    if (name == null) {
        throw new NullPointerException("name is marked non-null but is null");
    }
    this.name = name;
}

@RequiredArgsConstructor(staticName = "of")
public class User {
    @NonNull
    private final String name;
    private int age;
}

// Использование:
User user = User.of("John");

public class Task130125_1 {
    public static void main(String[] args) {
        String s = "hello";
        s.concat(" world");
        s.replace("hello", "hi");
        System.out.println(s);
    }
}