public static void testDigest()

in src/com/amazon/corretto/crypto/provider/Utils.java [298:394]
82 lines of code
20 McCabe index (conditional complexity)

    public static void testDigest(MessageDigest md, byte[] message, byte[] expected) {
        final int[] lengths = new int[] { 1, 3, 4, 7, 8, 16, 32, 48, 64, 128, 256 };
        final String alg = md.getAlgorithm();
        assertArrayEquals(alg, expected, md.digest(message));
        for (int x = 0; x < message.length; x++) {
            md.update(message[x]);
        }
        assertArrayEquals(alg + "-Byte", expected, md.digest());
        for (final int length : lengths) {
            for (int x = 0; x < message.length; x += length) {
                final int len = x + length > message.length ? message.length - x : length;
                md.update(message, x, len);
            }
            assertArrayEquals(alg + "-" + length, expected, md.digest());
        }

        // Byte buffer wrapping
        md.update(ByteBuffer.wrap(message));
        assertArrayEquals(alg + "-ByteBuffer-Wrap", expected, md.digest());

        for (final int length : lengths) {
            for (int x = 0; x < message.length; x += length) {
                final int len = x + length > message.length ? message.length - x : length;
                md.update(ByteBuffer.wrap(message, x, len));
            }
            assertArrayEquals(alg + "-ByteBuffer-Wrap-" + length, expected, md.digest());
        }

        // Byte buffer wrapping, read-only
        md.update(ByteBuffer.wrap(message).asReadOnlyBuffer());
        assertArrayEquals(alg + "-ByteBuffer-Wrap-RO", expected, md.digest());

        for (final int length : lengths) {
            for (int x = 0; x < message.length; x += length) {
                final int len = x + length > message.length ? message.length - x : length;
                md.update(ByteBuffer.wrap(message, x, len).asReadOnlyBuffer());
            }
            assertArrayEquals(alg + "-ByteBuffer-Wrap-RO-" + length, expected, md.digest());
        }

        // Byte buffer non-direct
        ByteBuffer bbuff = ByteBuffer.allocate(message.length);
        bbuff.put(message);
        bbuff.flip();
        md.update(bbuff);
        assertArrayEquals(alg + "-ByteBuffer-NonDirect", expected, md.digest());

        for (final int length : lengths) {
            bbuff = ByteBuffer.allocate(length);
            for (int x = 0; x < message.length; x += length) {
                final int len = x + length > message.length ? message.length - x : length;
                bbuff.clear();
                bbuff.put(message, x, len);
                bbuff.flip();
                md.update(bbuff);
            }
            assertArrayEquals(alg + "-ByteBuffer-NonDirect-" + length, expected, md.digest());
        }

        // Byte buffer direct
        bbuff = ByteBuffer.allocateDirect(message.length);
        bbuff.put(message);
        bbuff.flip();
        md.update(bbuff);
        assertArrayEquals(alg + "-ByteBuffer-Direct", expected, md.digest());

        for (final int length : lengths) {
            bbuff = ByteBuffer.allocateDirect(length);
            for (int x = 0; x < message.length; x += length) {
                final int len = x + length > message.length ? message.length - x : length;
                bbuff.clear();
                bbuff.put(message, x, len);
                bbuff.flip();
                md.update(bbuff);
            }
            assertArrayEquals(alg + "-ByteBuffer-Direct-" + length, expected, md.digest());
        }

        // Byte buffer direct, read-only
        bbuff = ByteBuffer.allocateDirect(message.length);
        bbuff.put(message);
        bbuff.flip();
        md.update(bbuff.asReadOnlyBuffer());
        assertArrayEquals(alg + "-ByteBuffer-Direct", expected, md.digest());

        for (final int length : lengths) {
            bbuff = ByteBuffer.allocateDirect(length);
            for (int x = 0; x < message.length; x += length) {
                final int len = x + length > message.length ? message.length - x : length;
                bbuff.clear();
                bbuff.put(message, x, len);
                bbuff.flip();
                md.update(bbuff.asReadOnlyBuffer());
            }
            assertArrayEquals(alg + "-ByteBuffer-Direct-" + length, expected, md.digest());
        }
    }