int64(73220195),            // Int64N(1000000000)
	int64(686060398),           // Int64N(1073741824)

	int64(0),                   // IntN(1)
	int64(6),                   // IntN(10)
	int64(8),                   // IntN(32)
	int64(704922),              // IntN(1048576)
	int64(245656),              // IntN(1048577)
	int64(41205257),            // IntN(1000000000)
	int64(43831929),            // IntN(1073741824)

	// HighestUserDefinablePriority is the highest priority for user defined priority classes. Priority values larger than 1 billion are reserved for Kubernetes system use.
	HighestUserDefinablePriority = int32(1000000000)
	// SystemCriticalPriority is the beginning of the range of priority values for critical system components.
	SystemCriticalPriority = 2 * HighestUserDefinablePriority

        assertEquals("1000", FessFunctions.formatFileSize(1000));
        assertEquals("976.6K", FessFunctions.formatFileSize(1000000));
        assertEquals("953.7M", FessFunctions.formatFileSize(1000000000));
        assertEquals("931.3G", FessFunctions.formatFileSize(1000000000000L));
        assertEquals("909.5T", FessFunctions.formatFileSize(1000000000000000L));
    }

    public void test_parseDate() {

		throw("sem_init")
	}
	mp.waitsema = uintptr(unsafe.Pointer(sem))
}

//go:nosplit
func semasleep(ns int64) int32 {
	mp := getg().m
	if ns >= 0 {
		mp.ts.tv_sec = ns / 1000000000
		mp.ts.tv_nsec = ns % 1000000000

		mp.libcall.fn = uintptr(unsafe.Pointer(&libc_sem_reltimedwait_np))
		mp.libcall.n = 2
		mp.scratch = mscratch{}
		mp.scratch.v[0] = mp.waitsema

	assert.Equal(t, uint64(0), getCPUWeight(nil))

	v := uint64(2)
	assert.Equal(t, uint64(1), getCPUWeight(&v))

	v = uint64(262144)
	assert.Equal(t, uint64(10000), getCPUWeight(&v))

	v = uint64(1000000000)
	assert.Equal(t, uint64(10000), getCPUWeight(&v))
}

func TestSoftRequirementsValidationSuccess(t *testing.T) {
	if cgroups.IsCgroup2UnifiedMode() {
		t.Skip("skipping cgroup v1 test on a cgroup v2 system")

	_CLOCK_MONOTONIC = 10
)

//go:nosplit
func nanotime1() int64 {
	tp := &timespec{}
	if clock_gettime(_CLOCK_REALTIME, tp) != 0 {
		throw("syscall clock_gettime failed")
	}
	return tp.tv_sec*1000000000 + tp.tv_nsec
}

func walltime() (sec int64, nsec int32) {
	ts := &timespec{}
	if clock_gettime(_CLOCK_REALTIME, ts) != 0 {
		throw("syscall clock_gettime failed")
	}
	return ts.tv_sec, int32(ts.tv_nsec)

        assertEquals("1.0 GB", format.format(_999_megabytes, ScaleUnit.GIGABYTE));

        long _1000_megabytes = 1000L * 1000L * 1000L;
        assertEquals("1.0 GB", format.format(_1000_megabytes));
        assertEquals("1000000000 B", format.format(_1000_megabytes, ScaleUnit.BYTE));
        assertEquals("1000000 kB", format.format(_1000_megabytes, ScaleUnit.KILOBYTE));
        assertEquals("1000 MB", format.format(_1000_megabytes, ScaleUnit.MEGABYTE));

			div: 2,
			ret: 4,
			rem: 0,
		},
		{
			num: 9,
			div: 2,
			ret: 4,
			rem: 1,
		},
		{
			// Used by runtime.check.
			num: 12345*1000000000 + 54321,
			div: 1000000000,
			ret: 12345,
			rem: 54321,
		},
		{
			num: 1<<32 - 1,
			div: 2,
			ret: 1<<31 - 1, // no overflow.
			rem: 1,
		},
		{
			num: 1 << 32,
			div: 2,

	// we cannot receive another signal.
	MOVD	40(R1), R6
	MOVD	R6, m_vdsoSP(R21)
	MOVD	32(R1), R6
	MOVD	R6, m_vdsoPC(R21)

return:
	// sec is in R3, nsec in R5
	// return nsec in R3
	MOVD	$1000000000, R4
	MULLD	R4, R3
	ADD	R5, R3
	MOVD	R3, ret+0(FP)
	RET

	// Syscall fallback
fallback:
	ADD	$32, R1, R4
	SYSCALL $SYS_clock_gettime
	MOVD	32(R1), R3
	MOVD	40(R1), R5
	JMP	return

	t0 := runtime.Nanotime1()
	var secrem uint32
	var nsecrem uint32
	total := time.Sec*1000000000 + time.Nsec
	elapsed := runtime.Nanotime1() - t0
	var rv int32
	var rc int32
	var err error
	// repeatedly sleep for 1 second until less than 1 second left
	for total-elapsed > 1000000000 {
		rv, rc, _ = BpxCondTimedWait(uint32(1), uint32(0), uint32(CW_CONDVAR), &secrem, &nsecrem)