* Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.fscc;

import java.util.Date;

import jcifs.internal.SMBProtocolDecodingException;

	}
	writer.Write(nil)
	if !writer.HasWritten() {
		t.Error("WriteOnCloser must be marked as HasWritten")
	}

	writer = WriteOnClose(io.Discard)
	writer.Close()
	if !writer.HasWritten() {
		t.Error("WriteOnCloser must be marked as HasWritten")
	}
}

// Test for AppendFile.
func TestAppendFile(t *testing.T) {
	f, err := os.CreateTemp(t.TempDir(), "")
	if err != nil {
		t.Fatal(err)
	}

    /**
     * Local read access to the memory region
     */
    LOCAL_READ,

    /**
     * Local write access to the memory region
     */
    LOCAL_WRITE,

    /**
     * Remote read access to the memory region
     */
    REMOTE_READ,

    /**
     * Remote write access to the memory region
     */
    REMOTE_WRITE,

    /**
     * Memory bind access for advanced operations
     */

    }

    @Override
    public void rdmaWrite(RdmaMemoryRegion localRegion, long remoteAddress, int remoteKey, int length) throws IOException {
        // TCP fallback doesn't support real RDMA write
        throw new UnsupportedOperationException("RDMA write not supported by TCP fallback");
    }

    @Override
    public RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException {

  public void testWriteString() throws IOException {
    File temp = createTempFile();
    Files.write(I18N, temp, UTF_16LE);
    assertEquals(I18N, Files.toString(temp, UTF_16LE));
  }

  public void testWriteBytes() throws IOException {
    File temp = createTempFile();
    byte[] data = newPreFilledByteArray(2000);
    Files.write(data, temp);
    assertThat(Files.toByteArray(temp)).isEqualTo(data);

    tokenUrl="/api/oauth/token",
    scopes={"read": "Read access", "write": "Write access"},
)


async def get_token(token: Annotated[str, Depends(oauth2_scheme)]) -> str:
    return token


app = FastAPI(dependencies=[Depends(get_token)])


@app.get("/admin", dependencies=[Security(get_token, scopes=["read", "write"])])
async def read_admin():
    return {"message": "Admin Access"}

        smbRandomAccessFile.write(42);
        assertEquals(1, smbRandomAccessFile.getFilePointer());
    }

    @Test
    void testWriteByteArray() throws SmbException {
        byte[] testData = new byte[] { 0, 1, 2, 3, 4 };

        // Mock the write operation
        doAnswer(new Answer<Void>() {
            @Override

    /**
     * Write data to RDMA connection
     *
     * @param buffer buffer containing data to write
     * @param remoteAddress remote memory address for RDMA write
     * @param remoteKey remote memory key
     * @param length number of bytes to write
     * @return number of bytes actually written
     * @throws IOException if write operation fails
     */

  private var bytesWritten = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount == 0L) return // Avoid double-triggering.

    if (bytesWritten == triggerByteCount) {
      source.skip(byteCount)
      return
    }

    val toWrite = minOf(byteCount, triggerByteCount - bytesWritten)
    bytesWritten += toWrite

    delegate.write(source, toWrite)

	buf := make([]byte, 512)

	for b.Loop() {
		rb.Write(data)
		rb.Read(buf)
	}
}

func BenchmarkRingBuffer_AsyncRead(b *testing.B) {
	// Pretty useless benchmark, but it's here for completeness.
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

	go func() {
		for {
			rb.Read(buf)
		}
	}()

	for b.Loop() {
		rb.Write(data)
	}
}