libcore/luni/src/test/java/org/apache/harmony/luni/platform/OSMemoryTest.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.harmony.luni.platform;

import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.AndroidOnly;

import junit.framework.TestCase;

/**
 * Tests org.apache.harmony.luni.platform.OSMemory (via IMemorySystem).
 */
@TestTargetClass(org.apache.harmony.luni.platform.OSMemory.class)
public class OSMemoryTest extends TestCase {
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "memset",
        args = {}
    )
    public void testMemset() {
        IMemorySystem memory = Platform.getMemorySystem();
        
        int byteCount = 32;
        int ptr = memory.malloc(byteCount);
        try {
            // Ensure our newly-allocated block isn't zeroed.
            memory.setByte(ptr, (byte) 1);
            assertEquals((byte) 1, memory.getByte(ptr));
            // Check that we can clear memory.
            memory.memset(ptr, (byte) 0, byteCount);
            assertBytesEqual((byte) 0, ptr, byteCount);
            // Check that we can set an arbitrary value.
            memory.memset(ptr, (byte) 1, byteCount);
            assertBytesEqual((byte) 1, ptr, byteCount);
        } finally {
            memory.free(ptr);
        }
    }
    
    void assertBytesEqual(byte value, int ptr, int byteCount) {
        IMemorySystem memory = Platform.getMemorySystem();
        for (int i = 0; i < byteCount; ++i) {
            assertEquals(value, memory.getByte(ptr + i));
        }
    }
    
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "setIntArray",
        args = {}
    )
    public void testSetIntArray() {
        IMemorySystem memory = Platform.getMemorySystem();
        
        int[] values = { 3, 7, 31, 127, 8191, 131071, 524287, 2147483647 };
        int[] swappedValues = new int[values.length];
        for (int i = 0; i < values.length; ++i) {
            swappedValues[i] = swapInt(values[i]);
        }
        
        int scale = ICommonDataTypes.SIZEOF_JINT;
        int ptr = memory.malloc(scale * values.length);
        try {
            // Regular copy. Memset first so we start from a known state.
            memory.memset(ptr, (byte) 0, scale * values.length);
            memory.setIntArray(ptr, values, 0, values.length, false);
            assertIntsEqual(values, ptr);
            
            // Swapped copy.
            memory.memset(ptr, (byte) 0, scale * values.length);
            memory.setIntArray(ptr, values, 0, values.length, true);
            assertIntsEqual(swappedValues, ptr);
            
            // Swapped copies of slices (to ensure we test non-zero offsets).
            memory.memset(ptr, (byte) 0, scale * values.length);
            for (int i = 0; i < values.length; ++i) {
                memory.setIntArray(ptr + i * scale, values, i, 1, true);
            }
            assertIntsEqual(swappedValues, ptr);
        } finally {
            memory.free(ptr);
        }
    }
    
    private void assertIntsEqual(int[] expectedValues, int ptr) {
        IMemorySystem memory = Platform.getMemorySystem();
        for (int i = 0; i < expectedValues.length; ++i) {
            assertEquals(expectedValues[i], memory.getInt(ptr + ICommonDataTypes.SIZEOF_JINT * i));
        }
    }
    
    private static int swapInt(int n) {
        return (((n >>  0) & 0xff) << 24) |
               (((n >>  8) & 0xff) << 16) |
               (((n >> 16) & 0xff) <<  8) |
               (((n >> 24) & 0xff) <<  0);
    }
    
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "setShortArray",
        args = {}
    )
    public void testSetShortArray() {
        IMemorySystem memory = Platform.getMemorySystem();
        
        short[] values = { 0x0001, 0x0020, 0x0300, 0x4000 };
        short[] swappedValues = { 0x0100, 0x2000, 0x0003, 0x0040 };
        
        int scale = ICommonDataTypes.SIZEOF_JSHORT;
        int ptr = memory.malloc(scale * values.length);
        try {
            // Regular copy. Memset first so we start from a known state.
            memory.memset(ptr, (byte) 0, scale * values.length);
            memory.setShortArray(ptr, values, 0, values.length, false);
            assertShortsEqual(values, ptr);
            
            // Swapped copy.
            memory.memset(ptr, (byte) 0, scale * values.length);
            memory.setShortArray(ptr, values, 0, values.length, true);
            assertShortsEqual(swappedValues, ptr);
            
            // Swapped copies of slices (to ensure we test non-zero offsets).
            memory.memset(ptr, (byte) 0, scale * values.length);
            for (int i = 0; i < values.length; ++i) {
                memory.setShortArray(ptr + i * scale, values, i, 1, true);
            }
            assertShortsEqual(swappedValues, ptr);
        } finally {
            memory.free(ptr);
        }
    }
    
    private void assertShortsEqual(short[] expectedValues, int ptr) {
        IMemorySystem memory = Platform.getMemorySystem();
        for (int i = 0; i < expectedValues.length; ++i) {
            assertEquals(expectedValues[i], memory.getShort(ptr + ICommonDataTypes.SIZEOF_JSHORT * i));
        }
    }
    
    private static short swapShort(short n) {
        return (short) ((((n >>  0) & 0xff) << 8) | (((n >>  8) & 0xff) << 0));
    }
}