switch (tc.getConfig().getLanManCompatibility()) {
        case 0:
        case 1:
        case 2:
            byte[] signingKey = new byte[40];
            getUserSessionKey(tc, chlng, signingKey, 0);
            System.arraycopy(getUnicodeHash(tc, chlng), 0, signingKey, 16, 24);
            return signingKey;
        case 3:
        case 4:
        case 5:
            /*

    exit 1
fi

if [ -z "$FESS_CLASSPATH" ]; then
    echo "You must set the FESS_CLASSPATH var" >&2
    exit 1
fi

# Special-case path variables.
case `uname` in
    CYGWIN*)
        FESS_CLASSPATH=`cygpath -p -w "$FESS_CLASSPATH"`
        FESS_HOME=`cygpath -p -w "$FESS_HOME"`
        if [ "x$FESS_CONF_PATH" != "x" ] ; then

    fileSystem.read(file) {
      return readStory(this)
    }
  }

  /** Iterate through the hpack-test-case resources, only picking stories for the current draft.  */
  fun storiesForCurrentDraft(): Array<String> {
    val resource =
      HpackJsonUtil::class.java.getResource("/hpack-test-case")
        ?: return arrayOf()

    val testCaseDirectory = File(resource.toURI()).toOkioPath()

	return rt != NoResync
}

func (rt ResyncStatusType) String() string {
	switch rt {
	case ResyncStarted:
		return "Ongoing"
	case ResyncCompleted:
		return "Completed"
	case ResyncFailed:
		return "Failed"
	case ResyncPending:
		return "Pending"
	case ResyncCanceled:
		return "Canceled"
	default:
		return ""
	}
}

    for (Thread thread : blockedThreads) {
      AbstractFutureBenchmarks.awaitWaiting(thread);
    }
    switch (state) {
      case NOT_DONE:
        break;
      case FINISHED:
        f.set(null);
        break;
      case CANCELLED:
        f.cancel(false);
        break;
      case FAILED:
        f.setException(new Exception());
        break;
    }
    return f;
  }

            this.throwOnDecode = throwOnDecode;
        }
    }

    @BeforeEach
    void setUp() {
        ndrObject = new ConcreteNdrObject();
    }

    /**
     * Test case for the encode method.
     * Verifies that the encode method of a concrete implementation is called
     * and interacts with the NdrBuffer as expected.
     * @throws NdrException if encoding fails.
     */
    @Test

	*dst = dsync.LockResp{Code: dsync.RespOK}
	switch err {
	case nil:
	case errLockNotInitialized:
		dst.Code = dsync.RespLockNotInitialized
	case errLockConflict:
		dst.Code = dsync.RespLockConflict
	case errLockNotFound:
		dst.Code = dsync.RespLockNotFound
	default:
		dst.Code = dsync.RespErr
		dst.Err = err.Error()
	}
	return dst, nil

func convPartErrToInt(err error) int {
	err = unwrapAll(err)
	switch err {
	case nil:
		return checkPartSuccess
	case errFileNotFound, errFileVersionNotFound:
		return checkPartFileNotFound
	case errFileCorrupt:
		return checkPartFileCorrupt
	case errVolumeNotFound:
		return checkPartVolumeNotFound
	case errDiskNotFound:
		return checkPartDiskNotFound
	default:
		return checkPartUnknown
	}
}

    }

    @Test
    void constructor_shouldInitializeValueCorrectly() {
        // Test case 1: Positive value
        int positiveValue = 12345;
        NdrLong ndrLongPositive = new NdrLong(positiveValue);
        assertEquals(positiveValue, ndrLongPositive.value, "Constructor should correctly initialize with a positive value.");

        // Test case 2: Negative value
        int negativeValue = -54321;

		copy(t, s)
		for i := range len(s) {
			if s[i] == ' ' {
				t[i] = '+'
			}
		}
		return string(t)
	}

	j := 0
	for i := range len(s) {
		switch c := s[i]; {
		case c == ' ':
			t[j] = '+'
			j++
		case shouldEscape(c):
			t[j] = '%'
			t[j+1] = "0123456789ABCDEF"[c>>4]
			t[j+2] = "0123456789ABCDEF"[c&15]
			j += 3
		default:
			t[j] = s[i]
			j++
		}
	}
	return string(t)
}