// The zero value is automatically promoted to either TypeReg or TypeDir
	// depending on the presence of a trailing slash in Name.
	Typeflag byte

	Name     string // Name of file entry
	Linkname string // Target name of link (valid for TypeLink or TypeSymlink)

	Size  int64  // Logical file size in bytes
	Mode  int64  // Permission and mode bits
	Uid   int    // User ID of owner
	Gid   int    // Group ID of owner

    @DisplayName("getServerEncryptionKey returns expected bytes")
    void serverEncryptionKey_variants() {
        byte[] key = new byte[] { 1, 2, 3 };
        when(transport.getServerEncryptionKey()).thenReturn(key);
        assertArrayEquals(key, transport.getServerEncryptionKey());
        verify(transport).getServerEncryptionKey();

        // Empty array
        byte[] empty = new byte[0];

                "value": null
              },
              {
                "color": "red",
                "value": 80
              }
            ]
          },
          "unit": "bytes"
        },
        "overrides": []
      },
      "gridPos": {
        "h": 5,
        "w": 6,
        "x": 12,
        "y": 0
      },
      "id": 23,
      "options": {

            region.close();
            totalReleased.incrementAndGet();
        }
    }

    /**
     * Allocate a direct buffer for temporary use
     *
     * @param size buffer size in bytes
     * @return direct byte buffer
     */
    public ByteBuffer allocateBuffer(int size) {
        return ByteBuffer.allocateDirect(size);
    }

    /**
     * Release a temporary buffer
     *

            mappingOffset = mappingsBuffer.length
            mappingsBuffer.append(mappedTo)
          } else {
            mappingOffset = mappingIndex
          }

          // Write the range bytes.
          val b1 = mappedTo.length
          val b2 = (mappingOffset and 0x3f80) shr 7
          val b3 = mappingOffset and 0x7f
          rangesBuffer.writeByte(b1)
          rangesBuffer.writeByte(b2)

		return err
	}

	if vssLimit > 0 && vssLimit < humanize.GiByte {
		logger.Info("WARNING: maximum virtual memory limit (%s) is too small for 'go runtime', please consider setting `ulimit -v` to unlimited",
			humanize.IBytes(vssLimit))
	}

	if ctx.MemLimit > 0 {
		debug.SetMemoryLimit(int64(ctx.MemLimit))
	}

	// Do not use RLIMIT_AS as that is not useful and at times on systems < 4Gi

	AmzChecksumTypeFullObject = "FULL_OBJECT"
	AmzChecksumTypeComposite  = "COMPOSITE"

	// S3 Express API related constant reject it.
	AmzWriteOffsetBytes = "x-amz-write-offset-bytes"

	// Post Policy related
	AmzMetaUUID = "X-Amz-Meta-Uuid"
	AmzMetaName = "X-Amz-Meta-Name"

	// Delete special flag to force delete a bucket or a prefix
	MinIOForceDelete = "x-minio-force-delete"

    }
    server
      .url("/b")
      .toUrl()
      .openConnection()
      .getInputStream() // Should succeed.
  }

  /**
   * Throttle the request body by sleeping 500ms after every 3 bytes. With a 6-byte request, this
   * should yield one sleep for a total delay of 500ms.
   */
  @Test
  fun throttleRequest() {
    assumeNotWindows()
    server.enqueue(
      MockResponse()

    }

    @Test
    @DisplayName("Test writeBytesWireFormat returns 0")
    void testWriteBytesWireFormat() {
        response = new Smb2QueryDirectoryResponse(mockConfig, (byte) 0x03);
        byte[] dst = new byte[1024];
        int dstIndex = 0;

        int result = response.writeBytesWireFormat(dst, dstIndex);

        assertEquals(0, result);
    }

    @Test

    void testDecodeAvChannelBindings() throws CIFSException {
        byte[] data = new byte[] { (byte) 0xAA, (byte) 0xBB };
        byte[] avPairData = createAvPairData(AvPair.MsvAvChannelBindings, data);
        byte[] eolData = createEolData();

        byte[] fullData = new byte[avPairData.length + eolData.length];
        System.arraycopy(avPairData, 0, fullData, 0, avPairData.length);