path: root/src/test/java/org/apache/fop/afp/parser/MODCAParserTestCase.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.
 */

/* $Id$ */

package org.apache.fop.afp.parser;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.InputStream;
import java.util.Arrays;

import org.junit.Test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

/**
 * MODCAParser and MODCAParser.UnparsedStructuredField Unit tests
 */
public class MODCAParserTestCase {

    /** The carriage control character (0x5A) used to indicate the start of a structured field. */
    public static final byte CARRIAGE_CONTROL_CHAR = (byte)0x5A;
    /**ASCII carriage return control character*/
    public static final byte CARRIAGE_RETURN = (byte)0x0A;
    /**ASCII line feed control character */
    public static final byte LINE_FEED = (byte)0x0D;
    /** 8 byte introducer describe the SF */
    private static final int INTRODUCER_LENGTH = 8;

    /**
     * Test that the MODCA parser recognises carriage control (0x5A) as the Structured Field
     * delimeter
     *
     * @throws Exception *
     */
    @Test
    public void testReadNextStructuredField1() throws Exception {

        // carriage control (0x5A) delimits structured fields,
        // and control is handed to readStructuredField(DataInputStream)
        byte[][] goodInputStream = new byte[][]{
                new byte[]{CARRIAGE_CONTROL_CHAR}
        };

        for (byte[] b : goodInputStream) {
            try {
                new MODCAParser(new ByteArrayInputStream(b))
                        .readNextStructuredField();
                fail("BAD SF should throw EOF: " + byteArrayToString(b));
            } catch (EOFException eof) {
                //passed
            }
        }

        // EOFException thrown when reading the input stream are caught and
        // a null value is returned
        byte[][] badInputStream = new byte[][]{
                new byte[]{},
                new byte[]{CARRIAGE_RETURN},
                new byte[]{LINE_FEED}
        };

        for (byte[] b : badInputStream) {
            UnparsedStructuredField usf = new MODCAParser(new ByteArrayInputStream(b))
            .readNextStructuredField();
            assertNull(usf);
        }
    }


    /**
     * Test that the MODCA parser correctly constructs an UnparsedStructuredField
     * from a well formed structured field
     *
     * @throws Exception *
     */
    @Test
    public void testReadNextStructuredField2() throws Exception {

        // no extension data
        testSF((byte)0xd3, (byte)0xa8, (byte)0x89, //SFTypeID
                (byte)0, //flags excluding the bits for
                //extension present, segmented data and padding present
                false, false,
                new byte[]{0, 0},
                new byte[]{1}, null);

        // with extension data
        testSF((byte)0xd3, (byte)0xa8, (byte)0x89, //SFTypeID
                (byte)0, //flags excluding the bits for
                //extension present, segmented data and padding present
                false, false,
                new byte[]{0, 0},
                new byte[]{1}, new byte[]{10});

        // with ignored reserved bits
        testSF((byte)0xd3, (byte)0xa8, (byte)0x89, //SFTypeID
                (byte)0, //flags excluding the bits for
                //extension present, segmented data and padding present
                false, false,
                new byte[]{1, 2},
                new byte[]{1}, null);

        // with padding present and segmented data
        testSF((byte)0xd3, (byte)0xa8, (byte)0x89, //SFTypeID
                (byte)(1 << 3), //flags excluding the bits for
                //extension present, segmented data and padding present
                true, true,
                new byte[]{0, 0},
                new byte[]{1}, null);

     // with flags non zero
        testSF((byte)0xd3, (byte)0xa8, (byte)0x89, //SFTypeID
                (byte)(1 << 3), //flags excluding the bits for
                //extension present, segmented data and padding present
                false, false,
                new byte[]{0, 0},
                new byte[]{1}, null);
    }


    private void testSF(byte classCode, byte typeCode, byte categoryCode,
            byte flags, boolean segmentedData, boolean paddingPresent, byte[] reserved,
            byte[] data, byte[] extData) throws Exception {

        byte extDataLength = 0;
        boolean extensionPresent = (extData != null);

        if (extensionPresent) {
            flags = (byte)(flags | 0x01);
            extDataLength = (byte)(extData.length + 1); //length includes length byte
        }

        if (segmentedData) {
            flags = (byte)(flags | 0x04);
        }

        if (paddingPresent) {
            flags = (byte)(flags | 0x10);
        }

        short length = (short)(INTRODUCER_LENGTH + data.length + extDataLength);
        byte[] lengthBytes = new byte[]{(byte)(length >> 8), (byte)(length & 0xFF)};

        byte[] sfBytes = new byte[length];

        //introducer bytes
        sfBytes[0] = lengthBytes[0];
        sfBytes[1] = lengthBytes[1];
        sfBytes[2] = classCode;
        sfBytes[3] = typeCode;
        sfBytes[4] = categoryCode;
        sfBytes[5] = flags;
        sfBytes[6] = reserved[0];
        sfBytes[7] = reserved[1];

        if (extDataLength > 0) {
            sfBytes[8] = (byte)(extData.length + 1);
            System.arraycopy(extData, 0, sfBytes, 9, extData.length);
        }

        System.arraycopy(data, 0, sfBytes, length - data.length, data.length);


        byte[] delimiteredSF = new byte[length + 1];

        delimiteredSF[0] = (byte)0x5A;

        System.arraycopy(sfBytes, 0, delimiteredSF, 1, length);

        InputStream bis = new ByteArrayInputStream(delimiteredSF);

        UnparsedStructuredField actual =  new MODCAParser(bis)
        .readNextStructuredField();

        //check introducer
        assertEquals(length, actual.getSfLength());
        assertEquals(classCode, actual.getSfClassCode());
        assertEquals(typeCode, actual.getSfTypeCode());
        assertEquals(categoryCode, actual.getSfCategoryCode());
        assertEquals(extensionPresent, actual.isSfiExtensionPresent());
        assertEquals(segmentedData, actual.isSfiSegmentedData());
        assertEquals(paddingPresent, actual.isSfiPaddingPresent());

        byte[] introducerData = new byte[]{(byte)(length >> 8), (byte)(length & 0xFF),
                classCode,  typeCode, categoryCode, flags, reserved[0], reserved[1]};

        assertTrue(Arrays.equals(introducerData, actual.getIntroducerData()));

        //check data
        assertTrue(Arrays.equals(data, actual.getData()));

        //check extension data
        if (extData != null) {
            assertTrue(Arrays.equals(extData, actual.getExtData()));
        }
        assertEquals(
                (extData == null) ? 0 : extData.length + 1, // 1 byte for length byte
                        actual.getExtLength());

        assertTrue(Arrays.equals(data, actual.getData()));

        int expectedSfTypeID = ((classCode & 0xFF) << 16)
                | ((typeCode & 0xFF) << 8)
                | (categoryCode & 0xFF);

        assertEquals(expectedSfTypeID, actual.getSfTypeID());

        assertTrue(Arrays.equals(sfBytes, actual.getCompleteFieldAsBytes()));

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        actual.writeTo(baos);
        assertTrue(Arrays.equals(sfBytes, baos.toByteArray()));

    }


    private static String byteArrayToString(byte[] byteArray) {
        StringBuilder sb = new StringBuilder();
        for (byte b : byteArray) {
            sb.append(Integer.toHexString(b & 0xFF)).append(" ");
        }
        return sb.toString();
    }

}