package de.mike.tests;

import org.junit.Test;
   
public class NameDerTestKlasse {
        
   @Test
   public void irgendeinBeliebigerMethodenname() {
   }
                    
}

...
@BeforeClass
public static void doBeforeAllTests() { ... }

@AfterClass
public static void doAfterAllTests() { ... }

@Before
public void doBeforeEachTest() { ... }

@After
public void doAfterEachTest() { ... }

@Test
public void test1() { ... }

@Test
public void test2() { ... }
...

@BeforeClass - method

@Before - method
 Test 1 wird ausgeführt.
@After - method

@Before - method
 Test 2 wird ausgeführt.
@After - method

@AfterClass - method

@Category(de.mike.kata.Integrationtest.class)
public class MySpecialIntegrationTest {
   ...
}

import org.junit.Test;
import static org.junit.Assert.assertTrue;
 
public class SimpleTest {
 
   @Test
   public void test() {
      assertTrue("Das weiß doch jedes Kind.", 1+1 == 2);
   }
 
}

...
   @Test
   public void test() {
      assertThat(myObj, is(not(nullValue()));
   }
...

...
   assertThat("Fehler", meinZuPruefenderWert, is(erwarteterWert));
...

@Test
@Ignore("Test wird zu Testzwecken ausgeblendet.")
public void testSame() {
    assertThat(1, is(1));
}

@Test(timeout=1000)
public void testWithTimeout() {
  ...
}

@RunWith(Theories.class)
public class TheoryTest {

   @DataPoints
   public static Integer[] ints = new Integer[] { -1, 0, 1, 2 };

   @Theory
   public void testCommutative(final Integer a, final Integer b) {
      assertTrue(a + b == b + a);
   }
}

@RunWith(Parameterized.class)
    public class LinesOfCodeCounterTest {
    private LinesOfCodeCounter counter;
    private String code2Test;
    private int numberOfCodeLines;
     
    public LinesOfCodeCounterTest(String code, 
                       int numberOfLines,
                       String comment) {
        code2Test = code;
        numberOfCodeLines = numberOfLines;
        counter = new LinesOfCodeCounter();
    }
 
    @Parameters(name = "Test case {index} - {2}")
    public static Iterable data1() {
       return Arrays.asList(new Object[][] {
          { "public void doIt() {\n}", 2, "No comments" },
          { "// Kommentar\npublic void doIt() {\nSystem.out.println(\"Hello world!\");\n}", 3, "Line comment" },
          { "/* block comment \n second line \n*/\npublic void ...", 1, "Block comment" }
          });
    }
 
    @Test
    public void testSimpleCodeLines() {
          assertThat(counter.count(code2Test), is(numberOfCodeLines));
    }
}

@RunWith(JUnitParamsRunner.class)
public class LinesOfCodeCounterTest {
  @Test
  @Parameters(
      { "public void doIt() {\n}, 2, No comments" ,
         "// Kommentar\npublic void doIt() {\nSystem.out.println(\"Hello world!\");\n}, 3, Line comment" ,
         "/* block comment \n second line \n*/\npublic void ..., 1, Block comment" 
       }
      )
   public void testSimpleCodeLines(String code2Test, int numberOfLines, String failureText) {
         assertThat(failureText, counter.count(code2Test), is(numberOfLines));
   }
}

public RuleType ruleVariable = new RuleType();

public class TemporaryFolderWithRuleTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Test
    public void test() throws Exception {
        File file = folder.newFile("test.txt");
        assertTrue(file.exists());
    }
}

composer require --dev phpunit/phpunit

{
   ...
   "autoload-dev": {
        "psr-4": {
            "Your\\Basic\\Namespace\\Tests\\": "tests/"
        }
    },
    ...
}

<?php declare(strict_types=1);

namespace Kata\Tests\Kata;

use PHPUnit\Framework\TestCase;

class MyClassToCheckTest extends TestCase
{
    public function test_check_regular_case(): void
    {
        // Test Fixture
        
        // Test Execution
        
        // Test Assertions & Verifications
    }
}

<?php declare(strict_types=1);

namespace Kata\Tests\Kata;

use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;

class MyClassToCheckTest extends TestCase
{
    #[Test] 
    public function check_regular_case(): void
    {
        
    }
}

class MyClassToCheckTest extends TestCase
{
    public static function setUpBeforeClass(): void {}
    
    protected function setUp(): void {}
    
    #[Test] 
    public function check_regular_case(): void {}
    
    protected function tearDown(): void {}
    
    public static function tearDownAfterClass(): void {}

}

php vendor/bin/phpunit [several_options]

<properties>
    <powermock.version>1.7.1</powermock.version>
</properties>
<dependencies>
   <dependency>
      <groupId>org.powermock</groupId>
      <artifactId>powermock-module-junit4</artifactId>
      <version>${powermock.version}</version>
      <scope>test</scope>
   </dependency>
   <dependency>
      <groupId>org.powermock</groupId>
      <artifactId>powermock-api-mockito</artifactId>
      <version>${powermock.version}</version>
      <scope>test</scope>
   </dependency>
</dependencies>

@RunWith(PowerMockRunner.class)
@PrepareForTest( { YourClassWithStaticMethod.class })
public class YourTestCase {
   ...
}

@Test
public void testChangingInternalState() throws Exception {

   TypeWithReadonlyField sut = Whitebox.invokeConstructor(TypeWithReadonlyField.class);

   assertThat(sut.getValue(), is("internal"));
   Whitebox.setInternalState(sut, "value", "different");
   assertThat(sut.getValue(), is("different"));
}

// Beispiel für Methodenunterdrückung
@Test
public void testSuppressMethod() throws Exception {
   ...
   suppress(method(ExampleWithEvilMethod.class, "getEvilMessage"));
   ...
}

@RunWith(PowerMockRunner.class)
@PrepareForTest({ System.class })
public class MockSystemClassesTest {

   @Test
   public void assertThatMockingOfNonFinalSystemClassesWorks() {
      mockStatic(System.class);
      when(System.currentTimeMillis()).thenReturn(0L);
      assertThat(System.currentTimeMillis(), is(0L));
   }
}

package powermock;

public class ClassWithStaticMethods {

   public static int returnOne() {
      return 1;
   }

   public static int returnTwo() {
      return 2;
   }

   public static int returnThree() {
      return 3;
   }

}

package powermock;

import static org.hamcrest.CoreMatchers.is;
import static org.powermock.api.mockito.PowerMockito.mockStatic;
import static org.powermock.api.mockito.PowerMockito.when;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import static org.junit.Assert.assertThat;

@RunWith(PowerMockRunner.class)
@PrepareForTest(ClassWithStaticMethods.class)
public class ClassCallingStaticMethodsTest {

   @Test
   public void testMethod() throws Exception {
      mockStatic(ClassWithStaticMethods.class);
      when(ClassWithStaticMethods.returnOne()).thenReturn(100);
      when(ClassWithStaticMethods.returnTwo()).thenReturn(200);
      when(ClassWithStaticMethods.returnThree()).thenReturn(300);

      assertThat(new ClassCallingStaticMethods().sumOfAllCalls(), is(600));
   }
}