public TestSSTRecord(String name) 
{
              
        super(name);
        _test_file_path = System.getProperty(_test_file_path_property);
}

Creates new TestSSTRecord

Parameters:

name -

 public static  void main(String[] ignored_args) 
{
        System.out.println("Testing hssf.record.SSTRecord functionality");
        junit.textui.TestRunner.run(TestSSTRecord.class);
}

main method to run the unit tests

 public  void testProcessContinueRecord() throws IOException 
{
        byte[] testdata = readTestData("BigSSTRecord");
        byte[] input    = new byte[ testdata.length - 4 ];
        System.arraycopy(testdata, 4, input, 0, input.length);
        SSTRecord record         =
            new SSTRecord(LittleEndian.getShort(testdata, 0),
                          LittleEndian.getShort(testdata, 2), input);
        byte[]    continueRecord = readTestData("BigSSTRecordCR");
        input = new byte[ continueRecord.length - 4 ];
        System.arraycopy(continueRecord, 4, input, 0, input.length);
        record.processContinueRecord(input);
        assertEquals(1464, record.getNumStrings());
        assertEquals(688, record.getNumUniqueStrings());
        assertEquals(688, record.countStrings());
        byte[] ser_output = record.serialize();
        int    offset     = 0;
        short  type       = LittleEndian.getShort(ser_output, offset);
        offset += LittleEndianConsts.SHORT_SIZE;
        short length = LittleEndian.getShort(ser_output, offset);
        offset += LittleEndianConsts.SHORT_SIZE;
        byte[] recordData = new byte[ length ];
        System.arraycopy(ser_output, offset, recordData, 0, length);
        offset += length;
        SSTRecord testRecord = new SSTRecord(type, length, recordData);
        assertEquals(ContinueRecord.sid,
                     LittleEndian.getShort(ser_output, offset));
        offset += LittleEndianConsts.SHORT_SIZE;
        length = LittleEndian.getShort(ser_output, offset);
        offset += LittleEndianConsts.SHORT_SIZE;
        byte[] cr = new byte[ length ];
        System.arraycopy(ser_output, offset, cr, 0, length);
        offset += length;
        assertEquals(offset, ser_output.length);
        testRecord.processContinueRecord(cr);
        assertEquals(record, testRecord);
        // testing based on new bug report
        testdata = readTestData("BigSSTRecord2");
        input    = new byte[ testdata.length - 4 ];
        System.arraycopy(testdata, 4, input, 0, input.length);
        record = new SSTRecord(LittleEndian.getShort(testdata, 0),
                               LittleEndian.getShort(testdata, 2), input);
        byte[] continueRecord1 = readTestData("BigSSTRecord2CR1");
        input = new byte[ continueRecord1.length - 4 ];
        System.arraycopy(continueRecord1, 4, input, 0, input.length);
        record.processContinueRecord(input);
        byte[] continueRecord2 = readTestData("BigSSTRecord2CR2");
        input = new byte[ continueRecord2.length - 4 ];
        System.arraycopy(continueRecord2, 4, input, 0, input.length);
        record.processContinueRecord(input);
        byte[] continueRecord3 = readTestData("BigSSTRecord2CR3");
        input = new byte[ continueRecord3.length - 4 ];
        System.arraycopy(continueRecord3, 4, input, 0, input.length);
        record.processContinueRecord(input);
        byte[] continueRecord4 = readTestData("BigSSTRecord2CR4");
        input = new byte[ continueRecord4.length - 4 ];
        System.arraycopy(continueRecord4, 4, input, 0, input.length);
        record.processContinueRecord(input);
        byte[] continueRecord5 = readTestData("BigSSTRecord2CR5");
        input = new byte[ continueRecord5.length - 4 ];
        System.arraycopy(continueRecord5, 4, input, 0, input.length);
        record.processContinueRecord(input);
        byte[] continueRecord6 = readTestData("BigSSTRecord2CR6");
        input = new byte[ continueRecord6.length - 4 ];
        System.arraycopy(continueRecord6, 4, input, 0, input.length);
        record.processContinueRecord(input);
        byte[] continueRecord7 = readTestData("BigSSTRecord2CR7");
        input = new byte[ continueRecord7.length - 4 ];
        System.arraycopy(continueRecord7, 4, input, 0, input.length);
        record.processContinueRecord(input);
        assertEquals(158642, record.getNumStrings());
        assertEquals(5249, record.getNumUniqueStrings());
        assertEquals(5249, record.countStrings());
        ser_output = record.serialize();
        offset     = 0;
        type       = LittleEndian.getShort(ser_output, offset);
        offset     += LittleEndianConsts.SHORT_SIZE;
        length     = LittleEndian.getShort(ser_output, offset);
        offset     += LittleEndianConsts.SHORT_SIZE;
        recordData = new byte[ length ];
        System.arraycopy(ser_output, offset, recordData, 0, length);
        offset     += length;
        testRecord = new SSTRecord(type, length, recordData);
        for (int count = 0; count <  7; count++)
        {
            assertEquals(ContinueRecord.sid,
                         LittleEndian.getShort(ser_output, offset));
            offset += LittleEndianConsts.SHORT_SIZE;
            length = LittleEndian.getShort(ser_output, offset);
            offset += LittleEndianConsts.SHORT_SIZE;
            cr     = new byte[ length ];
            System.arraycopy(ser_output, offset, cr, 0, length);
            testRecord.processContinueRecord(cr);
            offset += length;
        }
        assertEquals(offset, ser_output.length);
        assertEquals(record, testRecord);
}

test processContinueRecord

 public  void testReaderConstructor() throws IOException 
{
        byte[] testdata = readTestData("BigSSTRecord");
        byte[] input    = new byte[ testdata.length - 4 ];
        System.arraycopy(testdata, 4, input, 0, input.length);
        SSTRecord record = new SSTRecord(LittleEndian.getShort(testdata, 0),
                                         LittleEndian.getShort(testdata, 2),
                                         input);
        assertEquals(1464, record.getNumStrings());
        assertEquals(688, record.getNumUniqueStrings());
        assertEquals(492, record.countStrings());
        assertEquals(1, record.getExpected());
        assertEquals("Consolidated B-24J Liberator The Dragon & His Tai",
                     record.getUnfinishedString());
        assertEquals(52, record.getTotalLength());
        assertEquals(3, record.getStringDataOffset());
        assertTrue(!record.isWideChar());
}

test reader constructor

 public  void testSimpleAddString() 
{
        SSTRecord record = new SSTRecord();
        String    s1     = "Hello world";
        // \u2122 is the encoding of the trademark symbol ...
        String    s2     = "Hello world\u2122";
        assertEquals(0, record.addString(s1));
        assertEquals(s1, record.getString(0));
        assertEquals(1, record.countStrings());
        assertEquals(1, record.getNumStrings());
        assertEquals(1, record.getNumUniqueStrings());
        byte[] output = record.constructBigStringArray();
        byte[] test1  = new byte[ 3 + s1.length() ];
        test1[ 0 ] = ( byte ) s1.length();
        test1[ 1 ] = ( byte ) 0;
        test1[ 2 ] = ( byte ) 0;
        char[] strdata = s1.toCharArray();
        for (int j = 0; j <  strdata.length; j++)
        {
            test1[ j + 3 ] = ( byte ) strdata[ j ];
        }
        assertEquals(test1.length, output.length);
        for (int j = 0; j <  test1.length; j++)
        {
            assertEquals(String.valueOf(j), test1[ j ], output[ j ]);
        }
        assertEquals(0, record.addString(s1));
        assertEquals(s1, record.getString(0));
        assertEquals(1, record.countStrings());
        assertEquals(2, record.getNumStrings());
        assertEquals(1, record.getNumUniqueStrings());
        output = record.constructBigStringArray();
        assertEquals(test1.length, output.length);
        for (int j = 0; j <  test1.length; j++)
        {
            assertEquals(String.valueOf(j), test1[ j ], output[ j ]);
        }
        assertEquals(1, record.addString(s2));
        assertEquals(s2, record.getString(1));
        assertEquals(2, record.countStrings());
        assertEquals(3, record.getNumStrings());
        assertEquals(2, record.getNumUniqueStrings());
        output = record.constructBigStringArray();
        byte[] test2 = new byte[ 6 + s1.length() + (2 * s2.length()) ];
        System.arraycopy(test1, 0, test2, 0, test1.length);
        int index = test1.length;
        test2[ index++ ] = ( byte ) s2.length();
        test2[ index++ ] = ( byte ) 0;
        test2[ index++ ] = ( byte ) 1;
        strdata          = s2.toCharArray();
        for (int j = 0; j <  strdata.length; j++)
        {
            test2[ index++ ] = ( byte ) strdata[ j ];
            test2[ index++ ] = ( byte ) (strdata[ j ]  > > 8);
        }
        assertEquals(test2.length, output.length);
        for (int j = 0; j <  test2.length; j++)
        {
            assertEquals(String.valueOf(j), test2[ j ], output[ j ]);
        }
        Iterator iter = record.getStrings();
        while (iter.hasNext())
        {
            UnicodeString ucs = ( UnicodeString ) iter.next();
            if (ucs.getString().equals(s1))
            {
                assertEquals(( byte ) 0, ucs.getOptionFlags());
            }
            else if (ucs.getString().equals(s2))
            {
                assertEquals(( byte ) 1, ucs.getOptionFlags());
            }
            else
            {
                fail("cannot match string: " + ucs.getString());
            }
        }
}

test simple addString

 public  void testSimpleConstructor() 
{
        SSTRecord record = new SSTRecord();
        assertEquals(0, record.getNumStrings());
        assertEquals(0, record.getNumUniqueStrings());
        assertEquals(0, record.countStrings());
        assertEquals(0, record.getExpected());
        assertEquals("", record.getUnfinishedString());
        assertEquals(0, record.getTotalLength());
        assertEquals(0, record.getStringDataOffset());
        assertTrue(!record.isWideChar());
        byte[] output   = record.serialize();
        byte[] expected =
        {
            ( byte ) record.getSid(), ( byte ) (record.getSid()  > > 8),
            ( byte ) 8, ( byte ) 0, ( byte ) 0, ( byte ) 0, ( byte ) 0,
            ( byte ) 0, ( byte ) 0, ( byte ) 0, ( byte ) 0, ( byte ) 0
        };
        assertEquals(expected.length, output.length);
        for (int k = 0; k <  expected.length; k++)
        {
            assertEquals(String.valueOf(k), expected[ k ], output[ k ]);
        }
}

test simple constructor