/**
     * Size of the transform header in bytes
     */
    public static final int TRANSFORM_HEADER_SIZE = 52;

    private final byte[] signature = new byte[16];
    private final byte[] nonce = new byte[16];
    private int originalMessageSize;
    private int flags;
    private long sessionId;

    /**
     * Create a new SMB2 Transform Header
     */
    public Smb2TransformHeader() {
    }

    /**

@DisplayName("NameServiceClientImpl Tests")
class NameServiceClientImplTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Configuration mockConfig;

    @Mock
    private NetbiosAddress mockNetbiosAddress;

    @Mock
    private Address mockAddress;

    private NameServiceClientImpl nameServiceClient;

    @BeforeEach
    void setUp() throws UnknownHostException {

 *
 */
@PlexusTest
@Deprecated
class LegacyRepositorySystemTest {
    @Inject
    private LegacyRepositorySystem repositorySystem;

    @Inject
    private ResolutionErrorHandler resolutionErrorHandler;

    @Inject
    private PlexusContainer container;

    @Inject
    private org.eclipse.aether.RepositorySystem resolverRepositorySystem;

    private static final String STATUS_RUNNING = "running";

    private static final String TARGET_ALL = "*";

    private final ObjectMapper objectMapper = new ObjectMapper();

    private String instanceId;

    private TimeoutTask pollTask;

    private long lastEventCheckTime;

    private final Map<String, List<Consumer<EventInfo>>> eventHandlers = new ConcurrentHashMap<>();

    /**
     * Default constructor.
     */

   * changes).
   */
  @Override
  public ImmutableMap<Object, Collection<Object>> asMap() {
    return super.asMap();
  }

  private Object readResolve() {
    return INSTANCE; // preserve singleton property
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

    return SUPPLIER.get();
  }

  private static final class PureJavaLongAddable extends AtomicLong implements LongAddable {
    @Override
    public void increment() {
      getAndIncrement();
    }

    @Override
    public void add(long x) {
      getAndAdd(x);
    }

    @Override
    public long sum() {
      return get();
    }
  }

  private LongAddables() {}

    setDefault(SubscriberExceptionContext.class, dummySubscriber.toContext());
    setDefault(Dispatcher.class, Dispatcher.immediate());
  }

  private static class DummySubscriber {

    private final EventBus eventBus = new EventBus();

    @Subscribe
    public void handle(@Nullable Object unused) {}

    Subscriber toSubscriber() throws Exception {

    assertFalse(permutationSet.contains(null));
  }

  private <T> void assertNextPermutation(
      List<T> expectedPermutation, Iterator<List<T>> permutations) {
    assertTrue("Expected another permutation, but there was none.", permutations.hasNext());
    assertEquals(expectedPermutation, permutations.next());
  }

  private <T> void assertNoMorePermutations(Iterator<List<T>> permutations) {

@ExtendWith(MockitoExtension.class)
class Kerb5ContextTest {

    @Mock
    private GSSManager gssManager;

    @Mock
    private GSSContext gssContext;

    @Mock
    private GSSName serviceName;

    @Mock
    private GSSName clientName;

    @Mock
    private GSSCredential clientCreds;

    private Kerb5Context ctx;
    private MockedStatic<GSSManager> mockedStatic;

    @BeforeEach

    protected SMB1SigningDigest digest = null;
    private ServerMessageBlock response;

    private final Configuration config;

    private Long expiration;

    private Exception exception;

    private boolean isError;

    private byte[] rawPayload;

    private boolean retainPayload;

    private String fullPath;
    private String server;
    private String domain;