Quelle AbstractCompressExpandTest.java Sprache: JAVA

/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import java.util.function.Supplier;
import java.util.random.RandomGenerator;

public abstract class AbstractCompressExpandTest {

    static int testCompress(int i, int mask) {
        int result = 0;
        int rpos = 0;
        while (mask != 0) {
            if ((mask & 1) != 0) {
                result |= (i & 1) << rpos;
                rpos++; // conditional increment
            }
            i >>>= 1; // unconditional shift-out
            mask >>>= 1;
        }
        return result;
    }

    static int testExpand(int i, int mask) {
        int result = 0;
        int rpos = 0;
        while (mask != 0) {
            if ((mask & 1) != 0) {
                result |= (i & 1) << rpos;
                i >>>= 1; // conditional shift-out
            }
            rpos++; // unconditional increment
            mask >>>= 1;
        }
        return result;
    }

    static long testCompress(long i, long mask) {
        long result = 0;
        int rpos = 0;
        while (mask != 0) {
            if ((mask & 1) != 0) {
                result |= (i & 1) << rpos++;
            }
            i >>>= 1;
            mask >>>= 1;
        }
        return result;
    }

    static long testExpand(long i, long mask) {
        long result = 0;
        int rpos = 0;
        while (mask != 0) {
            if ((mask & 1) != 0) {
                result |= (i & 1) << rpos;
                i >>>= 1;
            }
            rpos++;
            mask >>>= 1;
        }
        return result;
    }

    abstract int actualCompress(int i, int mask);

    abstract int actualExpand(int i, int mask);

    abstract int expectedCompress(int i, int mask);

    abstract int expectedExpand(int i, int mask);

    abstract long actualCompress(long i, long mask);

    abstract long actualExpand(long i, long mask);

    abstract long expectedCompress(long i, long mask);

    abstract long expectedExpand(long i, long mask);

    static int SIZE = 1024;

    <T> Supplier<T> supplierWithToString(Supplier<T> s, String name) {
        return new Supplier<>() {
            @Override
            public T get() {
                return s.get();
            }

            @Override
            public String toString() {
                return name;
            }
        };
    }

    @DataProvider
    Object[][] maskIntProvider() {
        RandomGenerator rg = RandomGenerator.getDefault();

        return new Object[][]{
                {supplierWithToString(() -> rg.ints(SIZE).toArray(), "random masks")},
                {supplierWithToString(this::contiguousMasksInt, "contiguous masks")}
        };
    }

    @DataProvider
    Object[][] maskLongProvider() {
        RandomGenerator rg = RandomGenerator.getDefault();

        return new Object[][]{
                {supplierWithToString(() -> rg.longs(SIZE).toArray(), "random masks")},
                {supplierWithToString(this::contiguousMasksLong, "contiguous masks")}
        };
    }

    int[] contiguousMasksInt() {
        int size = 32 * (32 + 1) / 2 + 1; // 528 + 1
        int[] masks = new int[size];

        int i = 0;
        masks[i++] = 0;
        for (int len = 1; len < 32; len++) {
            for (int pos = 0; pos <= 32 - len; pos++) {
                masks[i++] = ((1 << len) - 1) << pos;
            }
        }
        masks[i++] = -1;

        assert i == masks.length;
        return masks;
    }

    long[] contiguousMasksLong() {
        int size = 64 * (64 + 1) / 2 + 1; // 2080 + 1
        long[] masks = new long[size];

        int i = 0;
        masks[i++] = 0L;
        for (int len = 1; len < 64; len++) {
            for (int pos = 0; pos <= 64 - len; pos++) {
                masks[i++] = ((1L << len) - 1) << pos;
            }
        }
        masks[i++] = -1L;

        assert i == masks.length;
        return masks;
    }

    @Test(dataProvider = "maskIntProvider")
    public void testCompressInt(Supplier<int[]> maskProvider) {
        RandomGenerator rg = RandomGenerator.getDefault();

        int[] values = rg.ints(SIZE).toArray();
        int[] masks = maskProvider.get();

        for (int i : values) {
            for (int m : masks) {
                int actual = actualCompress(i, m);
                int expected = expectedCompress(i, m);
                if (actual != expected) {
                    print(i, m, actual, expected);
                }
                Assert.assertEquals(actual, expected);
            }
        }
    }

    @Test(dataProvider = "maskIntProvider")
    public void testExpandInt(Supplier<int[]> maskProvider) {
        RandomGenerator rg = RandomGenerator.getDefault();

        int[] values = rg.ints(SIZE).toArray();
        int[] masks = maskProvider.get();

        for (int i : values) {
            for (int m : masks) {
                int actual = actualExpand(i, m);
                int expected = expectedExpand(i, m);
                if (actual != expected) {
                    print(i, m, actual, expected);
                }
                Assert.assertEquals(actual, expected);
            }
        }
    }

    @Test(dataProvider = "maskIntProvider")
    public void testCompressExpandInt(Supplier<int[]> maskProvider) {
        RandomGenerator rg = RandomGenerator.getDefault();

        int[] values = rg.ints(SIZE).toArray();
        int[] masks = maskProvider.get();

        for (int i : values) {
            for (int m : masks) {
                {
                    int a = actualCompress(actualExpand(i, m), m);
                    Assert.assertEquals(a, normalizeCompressedValue(i, m));

                    int b = actualCompress(actualExpand(i, ~m), ~m);
                    Assert.assertEquals(b, normalizeCompressedValue(i, ~m));
                }

                {
                    int a = actualExpand(actualCompress(i, m), m);
                    // Clear unset mask bits
                    Assert.assertEquals(a, i & m);

                    int b = actualExpand(actualCompress(i, ~m), ~m);
                    Assert.assertEquals(a & b, 0);
                    Assert.assertEquals(a | b, i);
                }
            }
        }
    }

    @Test
    public void testContiguousMasksInt() {
        RandomGenerator rg = RandomGenerator.getDefault();

        int[] values = rg.ints(SIZE).toArray();

        for (int i : values) {
            assertContiguousMask(i, 0, 0L);
            for (int len = 1; len < 32; len++) {
                for (int pos = 0; pos <= 32 - len; pos++) {
                    int mask = ((1 << len) - 1) << pos;

                    assertContiguousMask(i, pos, mask);
                }
            }
            assertContiguousMask(i, 0, -1L);
        }
    }

    void assertContiguousMask(int i, int pos, int mask) {
        Assert.assertEquals(actualCompress(i, mask), (i & mask) >>> pos);
        Assert.assertEquals(actualExpand(i, mask), (i << pos) & mask);
    }

    @Test(dataProvider = "maskLongProvider")
    public void testCompressLong(Supplier<long[]> maskProvider) {
        RandomGenerator rg = RandomGenerator.getDefault();

        long[] values = rg.longs(SIZE).toArray();
        long[] masks = maskProvider.get();

        for (long i : values) {
            for (long m : masks) {
                long actual = actualCompress(i, m);
                long expected = expectedCompress(i, m);
                if (actual != expected) {
                    print(i, m, actual, expected);
                }
                Assert.assertEquals(actual, expected);
            }
        }
    }

    @Test(dataProvider = "maskLongProvider")
    public void testExpandLong(Supplier<long[]> maskProvider) {
        RandomGenerator rg = RandomGenerator.getDefault();

        long[] values = rg.longs(SIZE).toArray();
        long[] masks = maskProvider.get();

        for (long i : values) {
            for (long m : masks) {
                long actual = actualExpand(i, m);
                long expected = expectedExpand(i, m);
                if (actual != expected) {
                    print(i, m, actual, expected);
                }
                Assert.assertEquals(actual, expected);
            }
        }
    }

    @Test(dataProvider = "maskLongProvider")
    public void testCompressExpandLong(Supplier<long[]> maskProvider) {
        RandomGenerator rg = RandomGenerator.getDefault();

        long[] values = rg.longs(SIZE).toArray();
        long[] masks = maskProvider.get();

        for (long i : values) {
            for (long m : masks) {
                {
                    long a = actualCompress(actualExpand(i, m), m);
                    Assert.assertEquals(a, normalizeCompressedValue(i, m));

                    long b = actualCompress(actualExpand(i, ~m), ~m);
                    Assert.assertEquals(b, normalizeCompressedValue(i, ~m));
                }

                {
                    long a = actualExpand(actualCompress(i, m), m);
                    // Clear unset mask bits
                    Assert.assertEquals(a, i & m);

                    long b = actualExpand(actualCompress(i, ~m), ~m);
                    Assert.assertEquals(a & b, 0);
                    Assert.assertEquals(a | b, i);
                }
            }
        }
    }

    @Test
    public void testContiguousMasksLong() {
        RandomGenerator rg = RandomGenerator.getDefault();

        long[] values = rg.longs(SIZE).toArray();

        for (long i : values) {
            assertContiguousMask(i, 0, 0L);
            for (int len = 1; len < 64; len++) {
                for (int pos = 0; pos <= 64 - len; pos++) {
                    long mask = ((1L << len) - 1) << pos;

                    assertContiguousMask(i, pos, mask);
                }
            }
            assertContiguousMask(i, 0, -1L);
        }
    }

    void assertContiguousMask(long i, int pos, long mask) {
        Assert.assertEquals(actualCompress(i, mask), (i & mask) >>> pos);
        Assert.assertEquals(actualExpand(i, mask), (i << pos) & mask);
    }

    static int normalizeCompressedValue(int i, int mask) {
        int mbc = Integer.bitCount(mask);
        if (mbc != 32) {
            return i & ((1 << mbc) - 1);
        } else {
            return i;
        }
    }

    static long normalizeCompressedValue(long i, long mask) {
        int mbc = Long.bitCount(mask);
        if (mbc != 64) {
            return i & ((1L << mbc) - 1);
        } else {
            return i;
        }
    }

    static void print(int i, int m, int actual, int expected) {
        System.out.println(String.format("i = %s", Integer.toBinaryString(i)));
        System.out.println(String.format("m = %s", Integer.toBinaryString(m)));
        System.out.println(String.format("a = %s", Integer.toBinaryString(actual)));
        System.out.println(String.format("e = %s", Integer.toBinaryString(expected)));
    }

    static void print(long i, long m, long actual, long expected) {
        System.out.println(String.format("i = %s", Long.toBinaryString(i)));
        System.out.println(String.format("m = %s", Long.toBinaryString(m)));
        System.out.println(String.format("a = %s", Long.toBinaryString(actual)));
        System.out.println(String.format("e = %s", Long.toBinaryString(expected)));
    }
}

quality81%

¤ Dauer der Verarbeitung: 0.2 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.