// Then
        assertEquals(0, request.getCapabilities() & Smb2Constants.SMB2_GLOBAL_CAP_ENCRYPTION);
    }

    @Test
    @DisplayName("Should generate correct dialect list")
    void testDialectGeneration() {
        // Given
        when(mockConfig.getMinimumVersion()).thenReturn(DialectVersion.SMB210);

    private Trans2GetDfsReferral trans2GetDfsReferral;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    @DisplayName("Constructor should initialize with correct values")
    void testConstructor() throws Exception {
        // Given
        String filename = "\\\\server\\share\\file.txt";

        // When

    // set it as the name of the test.  Then in runTest we can reflectively load and invoke the
    // corresponding method on AbstractFutureTest in the correct classloader.
    TestSuite suite = new TestSuite(AbstractFutureFallbackAtomicHelperTest.class.getName());
    for (Method method : AbstractFutureTest.class.getDeclaredMethods()) {

        void shouldImplementFileSystemInformation() {
            assertTrue(FileSystemInformation.class.isAssignableFrom(FileFsSizeInformation.class));
        }

        @Test
        @DisplayName("Should return correct file system information class")
        void shouldReturnCorrectFileSystemInformationClass() {
            assertEquals(FileSystemInformation.FS_SIZE_INFO, fileFsSizeInfo.getFileSystemInformationClass());
        }
    }

import org.jspecify.annotations.Nullable;

/**
 * Abstract base class for tests that EventBus finds the correct subscribers.
 *
 * <p>The actual tests are distributed among the other classes in this package based on whether they
 * are annotated or abstract in the superclass.
 *
 * <p>This test must be outside the c.g.c.eventbus package to test correctly.
 *
 * @author Louis Wasserman
 */
abstract class AbstractEventBusTest<H> extends TestCase {

     */
    static boolean overflowInParse(long current, int digit, int radix) {
      if (current >= 0) {
        if (current < maxValueDivs[radix]) {
          return false;
        }
        if (current > maxValueDivs[radix]) {
          return true;
        }
        // current == maxValueDivs[radix]
        return digit > maxValueMods[radix];
      }

      // current < 0: high bit is set
      return true;
    }

            buildScanTags = listOf("Check"),
            subprojects = JsonBasedGradleSubprojectProvider(File("../.teamcity/subprojects.json")),
        )

    @Test
    fun `CompileAll parameters are correct`() {
        val linuxPaths =
            listOf(
                "%linux.java8.oracle.64bit%",
                "%linux.java11.openjdk.64bit%",
                "%linux.java17.openjdk.64bit%",

  <artifactId>valid-version-changelist</artifactId>
  <version>${changelist}</version>

  <description>
    This will test if the validation for the ci friendly versions
    is working correct.
  </description>

If you added the return type annotation, tools and editors would complain with a (correct) error telling you that your function is returning a type (e.g. a dict) that is different from what you declared (e.g. a Pydantic model).

    class GetterTests {

        @Test
        @DisplayName("getPtype should return correct packet type")
        void testGetPtype() {
            message.ptype = DcerpcConstants.RPC_PT_REQUEST;
            assertEquals(DcerpcConstants.RPC_PT_REQUEST, message.getPtype());
        }

        @Test
        @DisplayName("getFlags should return correct flags")
        void testGetFlags() {