private final List<CircuitBreakerListener> listeners = new CopyOnWriteArrayList<>();

    // Configuration
    private volatile int failureThreshold;
    private final int successThreshold;
    private final long resetTimeoutMillis;
    private final long halfOpenMaxAttempts;
    private final AtomicInteger halfOpenAttempts = new AtomicInteger(0);

    // Dynamic threshold adjustment
    private final boolean dynamicThresholdEnabled;

  BeforeEachCallback,
  AfterEachCallback {
  private val clientEventsList = mutableListOf<String>()
  private var testClient: OkHttpClient? = null
  private var uncaughtException: Throwable? = null
  private lateinit var testName: String
  private var defaultUncaughtExceptionHandler: Thread.UncaughtExceptionHandler? = null
  private var taskQueuesWereIdle: Boolean = false
  private val connectionListener = RecordingConnectionListener()

    private int nextEntryOffset;
    private int fileIndex;
    private long creationTime;
    private long lastAccessTime;
    private long lastWriteTime;
    private long changeTime;
    private long endOfFile;
    private long allocationSize;
    private int extFileAttributes;
    private int eaSize;
    private String shortName;
    private String filename;

    private ArtifactFilter collectionFilter;

    private ArtifactFilter resolutionFilter;

    // Needs to go away
    private List<ResolutionListener> listeners = new ArrayList<>();

    // This is like a filter but overrides all transitive versions
    private Map<String, Artifact> managedVersionMap;

    private boolean resolveRoot = true;

    private boolean resolveTransitively = false;

        }
    }

    @Nested
    @DisplayName("hashCode and equals tests")
    class HashCodeAndEqualsTests {

        private InetAddress inetAddress1;
        private InetAddress inetAddress2;
        private NbtAddress nbtAddress1;
        private NbtAddress nbtAddress2;

        @BeforeEach
        void setup() throws UnknownHostException {
            inetAddress1 = InetAddress.getByName("192.168.1.1");

    private static final Logger log = LoggerFactory.getLogger(NetServerEnumIterator.class);

    private final NetServerEnum2 request;
    private final NetServerEnum2Response response;
    private final SmbResource parent;
    private final SmbTreeHandleImpl treeHandle;
    private final ResourceNameFilter nameFilter;
    private final boolean workgroup;
    private int ridx;
    private FileEntry next;

    private static final Object[] EMPTY_ARGS = new Object[0];

    private final String propertyName;

    private final Class<?> propertyType;

    private Method readMethod;

    private Method writeMethod;

    private Field field;

    private final BeanDesc beanDesc;

    private Constructor<?> stringConstructor;

    private Method valueOfMethod;

public final class Smb3KeyDerivation {

    private static final byte[] SIGNCONTEXT_300 = toCBytes("SmbSign");
    private static final byte[] SIGNLABEL_300 = toCBytes("SMB2AESCMAC");
    private static final byte[] SIGNLABEL_311 = toCBytes("SMBSigningKey");

    private static final byte[] APPCONTEXT_300 = toCBytes("SmbRpc");
    private static final byte[] APPLABEL_300 = toCBytes("SMB2APP");

    // Test implementation of SsoAuthenticator for testing
    private static class TestSsoAuthenticator implements SsoAuthenticator {
        private LoginCredential loginCredential;
        private FessLoginAssist.LoginCredentialResolver lastResolver;
        private boolean resolverCalled = false;
        private Map<SsoResponseType, ActionResponse> responseMap = new HashMap<>();
        private String logoutUrl;

      return description;
    }
  }

  private Target empty;
  private Target disjoint;
  private Target superset;
  private Target nonEmptyProperSubset;
  private Target sameElements;
  private Target partialOverlap;
  private Target containsDuplicates;
  private Target nullSingleton;

  @Override
  public void setUp() throws Exception {
    super.setUp();