"internal/bytealg"
	"internal/filepathlite"
	"io"
	"io/fs"
	"slices"
)

type readdirMode int

const (
	readdirName readdirMode = iota
	readdirDirEntry
	readdirFileInfo
)

// Readdir reads the contents of the directory associated with file and
// returns a slice of up to n [FileInfo] values, as would be returned
// by [Lstat], in directory order. Subsequent calls on the same file will yield
// further FileInfos.
//

            line.setLength(0)
        }
        return result.toString()
    }

    def "reads from empty text"() {
        expect:
        def reader = new PreprocessingReader(new StringReader(""))
        !reader.readNextLine(new StringBuilder())
    }

    def "reads single line"() {
        expect:
        def reader = new PreprocessingReader(new StringReader("abc(123)"))

        then:
        symbols.size() == 4
        symbols*.name.containsAll(['multiply.cpp', 'sum.cpp', 'greeter.cpp', 'main.cpp'])
    }

    @Unroll("reads soname value with #language readelf output")
    def "reads soname value"() {
        when:
        def inputLines = input.readLines()

        then:
        ReadelfBinaryInfo.readSoName(inputLines) == 'heythere'

        where:

func pstring(b []byte, s string) []byte {
	b = pbit16(b, uint16(len(s)))
	n := copy(b, s)
	return b[n:]
}

// gbit8 reads an 8-bit number from b and returns it with the remaining slice of b.
func gbit8(b []byte) (uint8, []byte) {
	return uint8(b[0]), b[1:]
}

// gbit16 reads a 16-bit number in little-endian order from b and returns it with the remaining slice of b.
func gbit16(b []byte) (uint16, []byte) {

                _dst = _dst.deferred;
                int _sidss = num_sids;
                _dst.enc_ndr_long(_sidss);
                int _sidsi = _dst.index;
                _dst.advance(4 * _sidss);

                _dst = _dst.derive(_sidsi);
                for (int _i = 0; _i < _sidss; _i++) {
                    sids[_i].encode(_dst);
                }
            }
        }

     * true}. If {@code false}, unknown elements will be ignored instead of causing a failure.
     */
    String IS_STRICT = "org.apache.maven.toolchains.io.isStrict";

    /**
     * Reads the toolchains from the specified file.
     *
     * @param input The file to deserialize the toolchains from, must not be {@code null}.

#include "absl/strings/string_view.h"
#include "tensorflow/core/lib/core/status.h"
#include "tensorflow/core/platform/protobuf.h"

namespace tensorflow {

// Reads text (.pbtext) or binary (.pb) format of a proto message from the given
// buffer. Returns error status of the file is not found or malformed proto.
// Note that text protos can only be parsed when full protobuf::Message protos

 * limitations under the License.
 */
package org.gradle.internal.file;

import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;

/**
 * Reads from a {@link RandomAccessFile}. Each operation reads from and advances the current position of the file.
 *
 * <p>Closing this stream does not close the underlying file.
 */
// TODO Replace this with Channels.newInputStream(SeekableByteChannel)

     * true}. If {@code false}, unknown elements will be ignored instead of causing a failure.
     */
    String IS_STRICT = "org.apache.maven.settings.io.isStrict";

    /**
     * Reads the settings from the specified file.
     *
     * @param input The file to deserialize the settings from, must not be {@code null}.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test to make sure that equality functions (and hash
// functions) don't do unaligned reads on architectures
// that can't do unaligned reads. See issue 46283.

package test

import "testing"

type T1 struct {
	x          float32
	a, b, c, d int16 // memequal64
}
type T2 struct {
	x          float32