}

}

type reader struct{ io.Reader }
type readSeeker struct{ io.ReadSeeker }
type readBadSeeker struct{ io.ReadSeeker }

func (rbs *readBadSeeker) Seek(int64, int) (int64, error) { return 0, fmt.Errorf("illegal seek") }

// TestReadTruncation test the ending condition on various truncated files and
// that truncated files are still detected even if the underlying io.Reader
// satisfies io.Seeker.

&&e?this._monthsShortStrictRegex:this._monthsShortRegex)},pt.week=function(e){return Ce(e,this._week.dow,this._week.doy).week},pt.firstDayOfYear=function(){return this._week.doy},pt.firstDayOfWeek=function(){return this._week.dow},pt.weekdays=function(e,a){var t=i(this._weekdays)?this._weekdays:this._weekdays[e&&!0!==e&&this._weekdays.isFormat.test(a)?"format":"standalone"];return!0===e?Ue(t,this._week.dow):e?t[e.day()]:t},pt.weekdaysMin=function(e){return!0===e?Ue(this._weekdaysMin,this._week.d...

          violation; or

       2. upon express reinstatement by the Licensor.

     For the avoidance of doubt, this Section 6(b) does not affect any
     right the Licensor may have to seek remedies for Your violations
     of this Public License.

  c. For the avoidance of doubt, the Licensor may also offer the
     Licensed Material under separate terms or conditions or stop

	buf := NewReader(r)
	allocs := testing.AllocsPerRun(100, func() {
		r.Seek(0, io.SeekStart)
		buf.Reset(r)

		_, err := buf.ReadString('\n')
		if err != nil {
			t.Fatal(err)
		}
	})
	if allocs != 1 {
		t.Errorf("Unexpected number of allocations, got %f, want 1", allocs)

	if offset == 0 {
		// Special case - if offset is 0, then partIndex and partOffset are always 0.
		return 0, 0, nil
	}
	partOffset = offset
	// Seek until object offset maps to a particular part offset.
	for i, part := range fi.Parts {
		partIndex = i
		// Offset is smaller than size we have reached the proper part offset.
		if partOffset < part.Size {

		r.File = make([]*File, 0, end.directoryRecords)
	}
	r.Comment = end.comment
	rs := io.NewSectionReader(rdr, 0, size)
	if _, err = rs.Seek(r.baseOffset+int64(end.directoryOffset), io.SeekStart); err != nil {
		return err
	}
	buf := bufio.NewReader(rs)

	// The count of files inside a zip is truncated to fit in a uint16.

    /**
     * SMB command to check if a directory exists.
     */
    public static final byte SMB_COM_CHECK_DIRECTORY = (byte) 0x10;

    /**
     * SMB command to seek within a file.
     */
    public static final byte SMB_COM_SEEK = (byte) 0x12;

    /**
     * SMB command for file locking operations.
     */
    public static final byte SMB_COM_LOCKING_ANDX = (byte) 0x24;

		for _, list := range cfV1.Pools {
			pools = append(pools, poolArgs{
				args:          list,
				setDriveCount: setDriveCount,
			})
		}
	case "v2":
		cf := config.ServerConfig{}
		cfReader.Seek(0, io.SeekStart)
		if err = yaml.Unmarshal(rd, &cf); err != nil {
			return err
		}

		pools = make([]poolArgs, 0, len(cf.Pools))
		for _, list := range cf.Pools {
			driveCount := list.SetDriveCount

	return newBytesRSC([]byte(s))
}

func newBytesRSC(b []byte) io.ReadSeekCloser {
	r := bytes.NewReader(b)
	segmentReader := func(offset int64) (io.ReadCloser, error) {
		_, err := r.Seek(offset, io.SeekStart)
		if err != nil {
			return nil, err
		}
		return io.NopCloser(r), nil
	}
	return NewObjectReadSeekCloser(segmentReader, int64(len(b)))
}

type testResponseWriter struct {

pkg io, type Seeker interface { Seek }
pkg io, type Seeker interface, Seek(int64, int) (int64, error)
pkg io, type WriteCloser interface { Close, Write }
pkg io, type WriteCloser interface, Close() error
pkg io, type WriteCloser interface, Write([]uint8) (int, error)
pkg io, type WriteSeeker interface { Seek, Write }
pkg io, type WriteSeeker interface, Seek(int64, int) (int64, error)