},
		},
	},
	// Issue 66869: Don't skip over an EOCDR with a truncated comment.
	// The test file sneakily hides a second EOCDR before the first one;
	// previously we would extract one file ("file") from this archive,
	// while most other tools would reject the file or extract a different one ("FILE").
	{
		Name:  "comment-truncated.zip",
		Error: ErrFormat,
	},
}

func TestReader(t *testing.T) {

    Function<? super Integer, Y> g = SerializableTester.reserializeAndAssert(f);
    for (int i = 1; i < 5; i++) {
      // convoluted way to check that the same result happens from each
      Y expected = null;
      try {
        expected = f.apply(i);
      } catch (IllegalArgumentException e) {
        try {
          g.apply(i);
          fail();

import jcifs.dcerpc.UnicodeString;
import jcifs.dcerpc.msrpc.LsaPolicyHandle;
import jcifs.dcerpc.msrpc.lsarpc;

@ExtendWith(MockitoExtension.class)
class SIDCacheImplTest {

    // Helper to create a SID from text without throwing in the test body
    private static SID sid(String textual) {
        try {
            return new SID(textual);
        } catch (SmbException e) {
            throw new RuntimeException(e);
        }

        }
    }

    @Nested
    @DisplayName("ReadBytesWireFormat Tests")
    class ReadBytesWireFormatTests {

        @Test
        @DisplayName("Should read valid oplock break notification from buffer")
        void testReadValidOplockBreakNotification() throws Exception {
            // Create a valid buffer with structure size 24
            byte[] buffer = new byte[64];
            int bufferIndex = 0;

        setupCountField.setAccessible(true);
        assertEquals(128, setupCountField.get(response));
    }

    @Test
    @DisplayName("Test reading from different buffer positions")
    void testReadFromDifferentPositions() throws Exception {
        byte[] buffer = new byte[200];

        // Test at various positions in the buffer

	_ = w.w.CloseWithError(err)
	_ = w.r.CloseWithError(err)
	w.err = err
}

func (w *writerAt) Close() (err error) {
	switch {
	case len(w.buffer) > 0:
		err = errors.New("some file segments were not flushed from the queue")
		_ = w.w.CloseWithError(err)
	case w.err != nil:
		// No need to close here since both pipes were
		// closing inside TransferError()
		err = w.err
	default:
		err = w.w.Close()
	}

                    return new CurlResponse() {
                        @Override
                        public InputStream getContentAsStream() throws IOException {
                            // Use the actual file path from the DictionaryFile
                            return new FileInputStream(new File(file.getPath()));
                        }

                        @Override

			}
		}
		z.serverPools[0].erasureDisksMu.Lock()
		xl.getDisks = func() []StorageAPI {
			return erasureDisks
		}
		z.serverPools[0].erasureDisksMu.Unlock()
		// Fetch object from store.
		gr, err := xl.GetObjectNInfo(ctx, bucket, object, nil, nil, opts)
		if err != nil {
			if err != toObjectErr(errErasureReadQuorum, bucket, object) {

                return new SID(info.sid, jcifs.SID.SID_TYPE_DOMAIN, new UnicodeString(info.name, false).toString(), null, false);
            } catch (final IOException e) {
                throw new CIFSException("Failed to get SID from server", e);
            }
        }
    }

    @Override
    public SID[] getGroupMemberSids(final CIFSContext tc, final String authorityServerName, final jcifs.SID domsid, final int rid,

        offset += 4;
        SMBUtil.writeInt4((int) free, buffer, offset);
        offset += 4;
        SMBUtil.writeInt2(bytesPerSect, buffer, offset);

        // Decode from offset
        int bytesDecoded = smbInfoAllocation.decode(buffer, bufferIndex, 20);

        // Verify - actual implementation reads 20 bytes
        assertEquals(20, bytesDecoded);

        // Verify calculations