verify(request, times(1)).getName();
        }

        @Test
        @DisplayName("getName() should handle null return value")
        void testGetNameWithNull() {
            CreateContextRequest request = mock(CreateContextRequest.class);
            when(request.getName()).thenReturn(null);

            byte[] actualName = request.getName();
            assertNull(actualName);
        }

        @Test

                    && field.getType() == String.class && !field.getName().equals("serialVersionUID")) {

                // Check field name follows convention
                assertTrue("Field name should match pattern: " + field.getName(), labelPattern.matcher(field.getName()).matches());

                // Check field value follows convention
                field.setAccessible(true);

            assertEquals("", mockEntry.getName(), "second call returns empty");
            assertEquals(" ", mockEntry.getName(), "third call returns space");

            verify(mockEntry, times(3)).getName();
        }
    }

                mappedPlugin.setArtifactId( plugin.getArtifactId() );

                mappedPlugin.setPrefix( plugin.getPrefix() );

                mappedPlugin.setName( plugin.getName() );

                addPlugin( mappedPlugin );

                changed = true;
            }
        }

        Versioning versioning = sourceMetadata.getVersioning();

        when(mockNetbiosName.getName()).thenReturn(upperCase);
        assertEquals(upperCase, mockNetbiosName.getName());

        when(mockNetbiosName.getName()).thenReturn(lowerCase);
        assertEquals(lowerCase, mockNetbiosName.getName());

        when(mockNetbiosName.getName()).thenReturn(mixedCase);
        assertEquals(mixedCase, mockNetbiosName.getName());
    }

    @Test

            verify(response, times(1)).getName();
        }

        @Test
        @DisplayName("getName() should handle null return value")
        void testGetNameWithNull() {
            CreateContextResponse response = mock(CreateContextResponse.class);
            when(response.getName()).thenReturn(null);

            byte[] actualName = response.getName();
            assertEquals(null, actualName);
        }

            assertEquals(SMBProtocolDowngradeException.class.getName(), ex.toString());
        } else if (message.isEmpty()) {
            // Throwable.toString prints class + ": " (with space) even for empty string
            assertEquals(SMBProtocolDowngradeException.class.getName() + ": ", ex.toString());
        } else {
            assertEquals(SMBProtocolDowngradeException.class.getName() + ": " + message, ex.toString());
        }
    }

        assertEquals(entries2.length, entries3.length);

        for (int i = 0; i < entries1.length; i++) {
            assertEquals(entries1[i].getName(), entries2[i].getName());
            assertEquals(entries2[i].getName(), entries3[i].getName());
            assertEquals(entries1[i].getType(), entries2[i].getType());
            assertEquals(entries2[i].getType(), entries3[i].getType());
        }
    }

    String oldName = Thread.currentThread().getName();
    Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");
    Callable<@Nullable Void> callable =
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {
            assertEquals(Thread.currentThread().getName(), newName.get());
            return null;
          }
        };

    TestSuite suite = new TestSuite(AbstractFutureFallbackAtomicHelperTest.class.getName());
    for (Method method : AbstractFutureTest.class.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers()) && method.getName().startsWith("test")) {
        suite.addTest(
            TestSuite.createTest(AbstractFutureFallbackAtomicHelperTest.class, method.getName()));
      }
    }
    return suite;
  }

  @Override