return bw.Sum(nil)
	}
	return nil
}

// Returns the size of the file with bitrot protection
func bitrotShardFileSize(size int64, shardSize int64, algo BitrotAlgorithm) int64 {
	if algo != HighwayHash256S {
		return size
	}
	return ceilFrac(size, shardSize)*int64(algo.New().Size()) + size
}

// bitrotVerify a single stream of data.

            assertEquals(65535, buffer.getTflags());
        }

        @Test
        @DisplayName("Should handle minimum buffer size")
        void testMinimumBufferSize() {
            byte[] testBuffer = new byte[8]; // Minimum size for header

            int bytesDecoded = buffer.decode(testBuffer, 0, testBuffer.length);

            assertEquals(8, bytesDecoded);

            parent = list;
            this.allRecordCount = allRecordCount;
            pageSize = size;
            currentPageNumber = offset / size + 1;
            allPageCount = allRecordCount == 0 ? 0 : (allRecordCount - 1) / size + 1;
        }

        @Override
        public int size() {
            return parent.size();
        }

	bottom: 0;
	height: 4em;
	position: absolute;
	border-top: 1px solid;
	padding-top: 1em;
}

h1,
h2,
h3 {
	line-height: 32px;
}

h1 {
	font-size: 30px;
}

h2 {
	font-size: 24px;
}

h3 {
	font-size: 18px;
}

.form-control {
	border-radius: 0px;
}

legend{
	display: none;
}

/* header */

#searchOptions {
	position: fixed;
	z-index: 10;

    }

    @Test
    @DisplayName("Test decode with maximum buffer size")
    void testDecodeWithMaxBufferSize() throws SMBProtocolDecodingException {
        prepareMinimalSecurityDescriptorBuffer(testBuffer, 0, true, true, false);

        // Decode with exact size needed
        int size = securityDescriptor.decode(testBuffer, 0, 100);

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapSizeTester<K, V> extends AbstractMapTester<K, V> {
  public void testSize() {
    assertEquals("size():", getNumElements(), getMap().size());
  }

    }

    /**
     * Gets the size of the original unencrypted message
     *
     * @return the original message size
     */
    public int getOriginalMessageSize() {
        return this.originalMessageSize;
    }

    /**
     * Sets the size of the original unencrypted message
     *
     * @param originalMessageSize
     *            the original message size to set
     */

        // negative size -> reject
        when(smbFile.length()).thenReturn(-1L);
        assertFalse(filter.accept(smbFile), "Negative size should be rejected");
        verify(smbFile, times(1)).length();

        // zero size -> reject
        reset(smbFile);
        when(smbFile.length()).thenReturn(0L);
        assertFalse(filter.accept(smbFile), "Zero size should be rejected");

				CalculatedSHA256: sha256Hex,
			}
		}
		if r.size >= 0 && size >= 0 && r.size != size {
			return nil, SizeMismatch{Want: r.size, Got: size}
		}

		r.checksum = MD5
		r.contentSHA256 = SHA256
		if r.size < 0 && size >= 0 {
			r.src = etag.Wrap(ioutil.HardLimitReader(r.src, size), r.src)
			r.size = size
		}
		if r.actualSize <= 0 && actualSize >= 0 {
			r.actualSize = actualSize

}

// BucketUsageInfo - bucket usage info provides
// - total size of the bucket
// - total objects in a bucket
// - object size histogram per bucket
type BucketUsageInfo struct {
	Size uint64 `json:"size"`
	// Following five fields suffixed with V1 are here for backward compatibility
	// Total Size for objects that have not yet been replicated