/*******************************************************************************
* Copyright 2010 Cees De Groot, Alex Boisvert, Jan Kotek
*
* Licensed 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.jdbm;
import junit.framework.TestCase;
import java.util.Random;
/**
* This class contains all Unit tests for {@link RecordHeader}.
*/
public class RecordHeaderTest extends TestCase {
/**
* Test basics - read and write at an offset
*/
public void testReadWrite() throws Exception {
byte[] data = new byte[Storage.PAGE_SIZE];
PageIo test = new PageIo(0, data);
//RecordHeader hdr = new RecordHeader(test, (short) 6);
RecordHeader.setAvailableSize(test, (short) 6, 2345);
RecordHeader.setCurrentSize(test, (short) 6, 2300);
assertEquals("current size", 2300, RecordHeader.getCurrentSize(test, (short) 6));
assertEquals("available size", 2345, RecordHeader.getAvailableSize(test, (short) 6));
}
public void testRecordSize() {
System.out.println("MAX_RECORD_SIZE " + RecordHeader.MAX_RECORD_SIZE);
assertEquals("inconsistent rounding at max rec size",
RecordHeader.MAX_RECORD_SIZE, RecordHeader.roundAvailableSize(RecordHeader.MAX_RECORD_SIZE));
byte[] data = new byte[Storage.PAGE_SIZE];
PageIo test = new PageIo(0, data);
Random r = new Random();
//RecordHeader hdr = new RecordHeader(test, (short) 6);
for (int size = 2; size <= RecordHeader.MAX_RECORD_SIZE; size++) {
//set size
int currSize = size;
int availSize = RecordHeader.roundAvailableSize(currSize);
assertTrue(availSize - currSize < RecordHeader.MAX_SIZE_SPACE);
assertTrue(currSize <= availSize);
assertEquals("size rounding function does not provide consistent results " + availSize,
availSize, RecordHeader.roundAvailableSize(availSize));
//make sure it writes and reads back correctly
RecordHeader.setAvailableSize(test, (short) 6, availSize);
assertEquals("available size", availSize, RecordHeader.getAvailableSize(test, (short) 6));
RecordHeader.setCurrentSize(test, (short) 6, currSize);
assertEquals("current size", currSize, RecordHeader.getCurrentSize(test, (short) 6));
//try random size within given offset
int newCurrSize = availSize - r.nextInt(RecordHeader.MAX_SIZE_SPACE);
if (newCurrSize < 0) newCurrSize = 0;
RecordHeader.setCurrentSize(test, (short) 6, newCurrSize);
assertEquals("current size", newCurrSize, RecordHeader.getCurrentSize(test, (short) 6));
RecordHeader.setCurrentSize(test, (short) 6, 0);
size++;
// comment out next line to do full test
if (size > 1e6)
size = (int) (size * 1.01);
}
}
public void testMaxRecordSize() {
long max = 0;
for (int i = 0; i < 1e7; i++) {
int deconverted = RecordHeader.deconvertAvailSize(RecordHeader.convertAvailSize(i));
if (i == deconverted) {
max = i;
}
}
assertEquals("Maximal record size does not match the calculated one: " + max, max, RecordHeader.MAX_RECORD_SIZE);
}
public void testRoundingSmall() {
for (int i = 0; i <= Short.MAX_VALUE; i++) {
assertEquals(i, RecordHeader.convertAvailSize(i));
}
}
public void testRounding() {
for (int i = 0; i < RecordHeader.MAX_RECORD_SIZE; i++) {
int deconverted = RecordHeader.deconvertAvailSize(RecordHeader.convertAvailSize(i));
assertTrue("deconverted size is smaller than actual: " + i + " versus " + deconverted, deconverted >= i);
}
}
public void testSetCurrentSize() {
PageIo b = new PageIo(4l, new byte[Storage.PAGE_SIZE]);
short pos = 10;
RecordHeader.setAvailableSize(b, pos, 1000);
assertEquals(1000, RecordHeader.getAvailableSize(b, pos));
RecordHeader.setCurrentSize(b, pos, 900);
assertEquals(900, RecordHeader.getCurrentSize(b, pos));
RecordHeader.setCurrentSize(b, pos, 0);
assertEquals(0, RecordHeader.getCurrentSize(b, pos));
RecordHeader.setCurrentSize(b, pos, 1000 - 254);
assertEquals(1000 - 254, RecordHeader.getCurrentSize(b, pos));
short pos2 = 20;
RecordHeader.setAvailableSize(b, pos2, 10000);
assertEquals(10000, RecordHeader.getAvailableSize(b, pos2));
RecordHeader.setCurrentSize(b, pos2, 10000);
assertEquals(10000, RecordHeader.getCurrentSize(b, pos2));
}
}