return 0;
    }

    @Override
    protected int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override

	Prefix                Prefix   `xml:"Prefix,omitempty"`
	Tags                  []Tag    `xml:"Tag,omitempty"`
}

// isEmpty returns true if Tags field is null
func (a And) isEmpty() bool {
	return len(a.Tags) == 0 && !a.Prefix.set &&
		a.ObjectSizeGreaterThan == 0 && a.ObjectSizeLessThan == 0
}

// Validate - validates the And field
func (a And) Validate() error {

			} else {
				callMethod(v, "Register", c.name, c.h)
			}

			if e, ok := v.(error); !ok || e != nil {
				err = e
			}
		}

		if len(data.err) > 0 && err == nil {
			t.Errorf("callbacks tests #%v should got error %v, but not", idx+1, data.err)
		} else if len(data.err) == 0 && err != nil {
			t.Errorf("callbacks tests #%v should not got error, but got %v", idx+1, err)
		}

				if sz != 0 {
					gots = append(gots, oi)
				}
			})

			if len(gots) != len(test.wants) {
				t.Fatalf("Expected %d objects but got %d", len(test.wants), len(gots))
			}
			if slices.CompareFunc(gots, test.wants, func(g, w ObjectInfo) int {
				if g.VersionID == w.VersionID {
					return 0
				}
				return -1

		} else { // In a hole fragment
			bf := b[:min(int64(len(b)), holeEnd-sr.pos)]
			nf, err = tryReadFull(zeroReader{}, bf)
		}
		b = b[nf:]
		sr.pos += int64(nf)
		if sr.pos >= holeEnd && len(sr.sp) > 1 {
			sr.sp = sr.sp[1:] // Ensure last fragment always remains
		}
	}

	n = len(b0) - len(b)
	switch {
	case err == io.EOF:
		return n, errMissData // Less data in dense file than sparse file

                int len = 0;
                if ((this.negotiatedFlags2 & SmbConstants.FLAGS2_UNICODE) == SmbConstants.FLAGS2_UNICODE) {
                    len = Strings.findUNITermination(buffer, bufferIndex, 256);
                    this.server.oemDomainName = Strings.fromUNIBytes(buffer, bufferIndex, len);
                } else {
                    len = Strings.findTermination(buffer, bufferIndex, 256);

        int fid = 0x1234;
        int offset = 100;
        int remaining = 50;
        byte[] buffer = new byte[100];
        int off = 10;
        int len = 40;

        // Act
        SmbComWrite write = new SmbComWrite(fid, offset, remaining, buffer, off, len);

        // Assert
        assertEquals(fid, getFieldValue(write, "fid"), "FID should match constructor arg");

}

// Eval will return a lifecycle event for each object in objs
func (e *Evaluator) Eval(objs []ObjectOpts) ([]Event, error) {
	if len(objs) == 0 {
		return nil, nil
	}
	if len(objs) != objs[0].NumVersions {
		return nil, fmt.Errorf("number of versions mismatch, expected %d, got %d", objs[0].NumVersions, len(objs))
	}
	return e.eval(objs, time.Now().UTC()), nil

    private final byte[] pipeData;
    private final int pipeDataOff, pipeDataLen;

    TransCallNamedPipe(final String pipeName, final byte[] data, final int off, final int len) {
        name = pipeName;
        pipeData = data;
        pipeDataOff = off;
        pipeDataLen = len;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_CALL_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 0;

        final char[] out = new char[256];
        char ch;
        int len, p, i;

        if (pathInfo == null) {
            return null;
        }
        len = pathInfo.length();

        p = i = 0;
        while (p < len && pathInfo.charAt(p) == '/') {
            p++;
        }
        if (p == len) {
            return null;
        }

        /* collect server name */