this.registrationId = generateRegistrationId();
        this.shareName = shareName;
        this.serverAddress = serverAddress;
        this.serviceType = serviceType;
        this.version = WitnessVersion.VERSION_2; // Use latest by default
        this.registrationTime = System.currentTimeMillis();
        this.sequenceNumber = new AtomicLong(0);
        this.state = WitnessRegistrationState.REGISTERING;

                // server sent final token
                verifyMechListMIC(targ.getMechanismListMIC());
                if (!this.disableMic || this.requireMic) {
                    mechMIC = calculateMechListMIC();
                }
                this.completed = true;
            } else if (this.mechContext.isMICAvailable() && (!this.disableMic || this.requireMic)) {

        }
        if (this.signingKey == null) {
            throw new IllegalStateException("Signing key has been wiped");
        }
        Mac m;
        if (this.provider != null) {
            m = Mac.getInstance(this.algorithmName, this.provider);
        } else {
            m = Mac.getInstance(this.algorithmName);
        }
        m.init(new SecretKeySpec(this.signingKey, "HMAC"));
        return m;
    }

    public void test_printThreadDump() {
        // This test verifies that printThreadDump() method exists and can be called without exceptions
        try {
            ThreadDumpUtil.printThreadDump();
        } catch (Exception e) {
            fail("printThreadDump() should not throw exceptions: " + e.getMessage());
        }
    }

    public void test_printThreadDumpAsWarn() {

  val buffer = Buffer()

  /**
   * Reference count of the number of active sources reading this stream. When decremented to 0
   * resources are released and all following calls to [.newSource] return null. Guarded by this.
   */
  var sourceCount = 0

  val isClosed: Boolean
    get() = file == null

  @Throws(IOException::class)
  private fun writeHeader(

                super(session, trace);
                this.path = path;
                this.source = source;
                this.allowStubModel = allowStubModel;
                this.recursive = recursive;
                this.processPlugins = processPlugins;
                this.repositories = repositories;
            }

            @Nonnull
            @Override

  private RegularImmutableBiMap() {
    this.keyHashTable = null;
    this.alternatingKeysAndValues = new Object[0];
    this.keyOffset = 0;
    this.size = 0;
    this.inverse = (RegularImmutableBiMap<V, K>) this;
  }

  /** K-to-V constructor. */
  RegularImmutableBiMap(@Nullable Object[] alternatingKeysAndValues, int size) {
    this.alternatingKeysAndValues = alternatingKeysAndValues;
    this.size = size;
    this.keyOffset = 0;

                Path rootDirectory) {
            this.userProperties = userProperties;
            this.systemProperties = systemProperties;
            this.startTime = startTime;
            this.topDirectory = topDirectory;
            this.rootDirectory = rootDirectory;
        }

        public Builder withUserProperties(@Nonnull Map<String, String> userProperties) {
            this.userProperties = new HashMap<>(userProperties);

                this.groupId = groupId;
                this.artifactId = artifactId;
                this.version = version;
                this.classifier = classifier;
                this.extension = extension;
                this.type = type;
                this.coordinateString = coordinateString;
                this.scope = scope;
                this.optional = optional;

  @CanIgnoreReturnValue
  PrimitiveSink putShort(short s);

  /** Puts an int into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putInt(int i);

  /** Puts a long into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putLong(long l);

  /** Puts a float into this sink. */
  @CanIgnoreReturnValue
  PrimitiveSink putFloat(float f);

  /** Puts a double into this sink. */