}
      // Bool
      if (const int b_size = default_value.list().b_size()) {
        absl::InlinedVector<unsigned char, 4> b_vector;
        b_vector.reserve(b_size);
        for (int i = 0; i < b_size; i++) {
          b_vector.push_back(default_value.list().b(i));
        }
        TFE_OpSetAttrBoolList(op, attr_name, b_vector.data(), b_size);
      }
      // Type

	s := syscall.Statfs_t{}
	err = syscall.Statfs(path, &s)
	if err != nil {
		return Info{}, err
	}
	reservedBlocks := s.Bfree - s.Bavail
	info = Info{
		Total: uint64(s.Frsize) * (s.Blocks - reservedBlocks),
		Free:  uint64(s.Frsize) * s.Bavail,
		Files: s.Files,
		Ffree: s.Ffree,
		//nolint:unconvert
		FSType: getFSType(int64(s.Type)),
	}

	st := syscall.Stat_t{}
	err = syscall.Stat(path, &st)

                + ",allocationSize=" + this.allocationSize + ",extFileAttributes=" + this.extFileAttributes + ",eaSize=" + this.eaSize
                + ",shortName=" + this.shortName + ",filename=" + this.filename + "]");
    }

    public MimeMap() throws IOException {
        int n;

        in = new byte[IN_SIZE];
        final InputStream is = getClass().getClassLoader().getResourceAsStream("jcifs/smb1/util/mime.map");

        inLen = 0;
        while ((n = is.read(in, inLen, IN_SIZE - inLen)) != -1) {
            inLen += n;
        }
        if (inLen < 100 || inLen == IN_SIZE) {
            throw new IOException("Error reading jcifs/smb1/util/mime.map resource");

                    + ",changeTime=" + new Date(changeTime) + ",endOfFile=" + endOfFile + ",allocationSize=" + allocationSize
                    + ",extFileAttributes=" + extFileAttributes + ",fileNameLength=" + fileNameLength + ",eaSize=" + eaSize
                    + ",shortNameLength=" + shortNameLength + ",shortName=" + shortName + ",filename=" + filename + "]");
        }
    }

    int sid;
    boolean isEndOfSearch;
    int eaErrorOffset;

 *
 * @author higa
 */
public abstract class InputStreamUtil {

    /**
     * Do not instantiate.
     */
    protected InputStreamUtil() {
    }

    /** Default buffer size. */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link FileInputStream}.
     *
     * @param file the file (must not be {@literal null})
     * @return a {@link FileInputStream} to read from the file

    }

    static class TestSubSearcher extends RankFusionSearcher {

        private int mainSize;
        private int inSize;
        private int outSize;

        TestSubSearcher(int mainSize, int inSize, int outSize) {
            this.mainSize = mainSize;
            this.inSize = inSize;
            this.outSize = outSize;
        }

        @Override

                + ",allocationSize=" + info.allocationSize + ",extFileAttributes=" + info.extFileAttributes + ",fileNameLength="
                + info.fileNameLength + ",eaSize=" + info.eaSize + ",shortNameLength=" + info.shortNameLength + ",shortName="
                + info.shortName + ",filename=" + info.filename + "]";
        assertEquals(expected, info.toString());
    }

 *
 * @author higa
 */
public abstract class ReaderUtil {

    /**
     * Do not instantiate.
     */
    protected ReaderUtil() {
    }

    /** Default buffer size */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link Reader} to read from a file with the specified encoding.
     *
     * @param is
     *            the input stream (must not be {@literal null})

  DCHECK(tf_results->missing_unused_key_names_data.empty());

  size_t size = results.missing_unused_input_map_keys.size();
  tf_results->missing_unused_key_names.resize(size);
  tf_results->missing_unused_key_indexes.resize(size);

  for (int i = 0; i < size; ++i) {
    TensorId id = results.missing_unused_input_map_keys[i];
    tf_results->missing_unused_key_names_data.emplace_back(id.first);
    tf_results->missing_unused_key_names[i] =