} finally {
            out.close();
        }

        // Set maxSize larger than file size
        final byte[] bytes = FileUtil.readBytes(file, 1024);
        assertThat(new String(bytes, "UTF-8"), is(content));
    }

    /**
     * Test readBytes with custom maxSize - file exceeds limit
     *
     * @throws Exception
     */
    @Test(expected = IORuntimeException.class)

            false, false, "Long", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnMaxSize = cci("maxSize", "maxSize", null, null, Integer.class, "maxSize", null, false, false, false,
            "Integer", 0, 0, null, null, false, null, null, null, null, null, false);

     */
    public static byte[] readBytes(final File file, final long maxSize) {
        assertArgumentNotNull("file", file);

        final FileInputStream is = InputStreamUtil.create(file);
        try {
            final FileChannel channel = is.getChannel();
            final long fileSize = ChannelUtil.size(channel);

            if (fileSize > maxSize) {

                                    <label for="maxSize" class="col-sm-3 text-sm-right col-form-label"><la:message
                                            key="labels.key_match_size"/></label>
                                    <div class="form-inline col-sm-9">
                                        <la:errors property="maxSize"/>
                                        <input type="number" name="maxSize" id="maxSize"

                                    <tr>
                                        <th><la:message key="labels.key_match_size"/></th>
                                        <td>${f:h(maxSize)}<la:hidden property="maxSize"/></td>
                                    </tr>
                                    <tr>
                                        <th><la:message key="labels.key_match_boost"/></th>

    protected void enforceMaxSize() {
        final int maxSize = getMaxSessionSize();
        synchronized (sessionCache) {
            if (sessionCache.size() <= maxSize) {
                return;
            }

            final int toRemove = sessionCache.size() - maxSize;
            logger.warn("Session cache reached maximum size. Removing oldest sessions. currentSize={}, maxSize={}, removing={}",

      }

      @Override
      int minSize() {
        int difference = minSize(set1) - maxSize(set2);
        return difference >= 0 ? difference : max(minSize(set2) - maxSize(set1), 0);
      }

      @Override
      int maxSize() {
        return saturatedAdd(maxSize(set1), maxSize(set2));
      }
    };
  }

  /**

          new MessageDigestHashFunction(algorithmName, bytes, algorithmName).hashBytes(input));
    }
    int maxSize = digest.getDigestLength();
    assertThrows(
        IllegalArgumentException.class,
        () -> new MessageDigestHashFunction(algorithmName, maxSize + 1, algorithmName));
  }

  constructor(directory: File, maxSize: Long) : this(
    FileSystem.SYSTEM,
    directory.toOkioPath(),
    maxSize,
  )

  internal val cache =
    DiskLruCache(
      fileSystem = fileSystem,
      directory = directory,
      appVersion = VERSION,
      valueCount = ENTRY_COUNT,
      maxSize = maxSize,
      taskRunner = taskRunner,
    )

    }
  }

  public void testSetMaximumSize() {
    // vary maximumSize wrt concurrencyLevel

    for (int maxSize = 1; maxSize < 100; maxSize++) {
      checkMaximumSize(1, 8, maxSize);
      checkMaximumSize(2, 8, maxSize);
      checkMaximumSize(4, 8, maxSize);
      checkMaximumSize(8, 8, maxSize);
    }

    checkMaximumSize(1, 8, Long.MAX_VALUE);
    checkMaximumSize(2, 8, Long.MAX_VALUE);