bookkeeper-server/src/test/java/org/apache/bookkeeper/util/TestZeroBuffer.java

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */
package org.apache.bookkeeper.util;

import java.nio.ByteBuffer;
import java.util.Random;

import org.junit.Assert;
import org.junit.Test;

/**
 * Testcases for ZeroBuffer.
 */
public class TestZeroBuffer {

    @Test
    public void testPut() {
        ByteBuffer testBuffer;
        byte[] testBufferArray;
        Random rand = new Random();

        // Test1 - trying ZeroBuffer.put on small sized TestBuffer
        testBuffer = ByteBuffer.allocate(5);
        testBufferArray = testBuffer.array();
        testBufferArray[4] = 7;
        Assert.assertFalse("Test1 - It is supposed to contain non-zero byte", isFilledWithZeros(testBufferArray, 0, 5));
        ZeroBuffer.put(testBuffer);
        Assert.assertTrue("Test1 - After calling, ZeroBuffer.put There aren't supposed to be non-zero bytes",
                isFilledWithZeros(testBufferArray, 0, 5));

        // Test2 - trying ZeroBuffer.put on 64*1024 sized TestBuffer
        testBuffer = ByteBuffer.allocate(64 * 1024);
        testBufferArray = testBuffer.array();
        rand.nextBytes(testBufferArray);
        Assert.assertFalse("Test2 - It is supposed to contain random non-zero bytes",
                isFilledWithZeros(testBufferArray, 0, 64 * 1024));
        ZeroBuffer.put(testBuffer);
        Assert.assertTrue("Test2 - After calling, ZeroBuffer.put There aren't supposed to be non-zero bytes",
                isFilledWithZeros(testBufferArray, 0, 64 * 1024));

        // Test3 - trying ZeroBuffer.put on portion (64*1024) of large sized
        // TestBuffer (256*1024)
        testBuffer = ByteBuffer.allocate(256 * 1024);
        testBufferArray = testBuffer.array();
        rand.nextBytes(testBufferArray);
        Assert.assertFalse("Test3 - It is supposed to contain random non-zero bytes",
                isFilledWithZeros(testBufferArray, 64 * 1024, 64 * 1024));
        testBuffer.position(64 * 1024);
        ZeroBuffer.put(testBuffer, 64 * 1024);
        Assert.assertTrue(
                "Test3 - After calling, ZeroBuffer.put There aren't supposed to be non-zero bytes "
                + "in the particular section", isFilledWithZeros(testBufferArray, 64 * 1024, 64 * 1024));
        Assert.assertFalse("Test3 - After calling, ZeroBuffer.put other sections shouldnt be touched",
                isFilledWithZeros(testBufferArray, 0, 64 * 1024));
        Assert.assertFalse("Test3 - After calling, ZeroBuffer.put other sections shouldnt be touched",
                isFilledWithZeros(testBufferArray, 128 * 1024, 128 * 1024));
    }

    @Test
    public void testReadOnlyBuffer() {
        ByteBuffer testReadOnlyBuffer;
        byte[] testBufferArray;

        // Test1 - trying ZeroBuffer.readOnlyBuffer for small size
        testReadOnlyBuffer = ZeroBuffer.readOnlyBuffer(5);
        Assert.assertTrue(
                "Test1 - ReadOnlyBuffer should have remaining 5 bytes but it has " + testReadOnlyBuffer.remaining(),
                testReadOnlyBuffer.remaining() == 5);
        testBufferArray = new byte[5];
        testReadOnlyBuffer.get(testBufferArray);
        Assert.assertTrue("Test1 - supposed to contain only zero bytes", isFilledWithZeros(testBufferArray, 0, 5));

        // Test2 - trying ZeroBuffer.readOnlyBuffer for 64*1024
        testReadOnlyBuffer = ZeroBuffer.readOnlyBuffer(64 * 1024);
        Assert.assertTrue("Test2 - ReadOnlyBuffer should have remaining 64*1024 bytes but it has "
                + testReadOnlyBuffer.remaining(), testReadOnlyBuffer.remaining() == 64 * 1024);
        testBufferArray = new byte[64 * 1024];
        testReadOnlyBuffer.get(testBufferArray);
        Assert.assertTrue("Test2 - supposed to contain only zero bytes",
                isFilledWithZeros(testBufferArray, 0, 64 * 1024));

        // Test3 - trying ZeroBuffer.readOnlyBuffer for > 64*1024
        testReadOnlyBuffer = ZeroBuffer.readOnlyBuffer(128 * 1024);
        Assert.assertTrue("Test3 - ReadOnlyBuffer should have remaining 128*1024 bytes but it has "
                + testReadOnlyBuffer.remaining(), testReadOnlyBuffer.remaining() == 128 * 1024);
        testBufferArray = new byte[128 * 1024];
        testReadOnlyBuffer.get(testBufferArray);
        Assert.assertTrue("Test3 - supposed to contain only zero bytes",
                isFilledWithZeros(testBufferArray, 0, 128 * 1024));
    }

    boolean isFilledWithZeros(byte[] byteArray, int start, int length) {
        for (int i = start; i < (start + length); i++) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }
}