teststyletextpropatom.java

java 读写word excel ppt

		assertEquals(false,cf_4_1.getSubValue(CharFlagsTextProp.SHADOW_IDX));
		assertEquals(false,cf_4_1.getSubValue(CharFlagsTextProp.STRIKETHROUGH_IDX));
		assertEquals(false,cf_4_1.getSubValue(CharFlagsTextProp.UNDERLINE_IDX));
		
		// The value should now be 3
		assertEquals(0x0003, cf_4_1.getValue());
	}
	
	public void testFindAddTextProp() {
		StyleTextPropAtom stpb = new StyleTextPropAtom(data_b,0,data_b.length);
		stpb.setParentTextSize(data_b_text_len);

		LinkedList b_p_l = stpb.getParagraphStyles();
		TextPropCollection b_p_1 = (TextPropCollection)b_p_l.get(0);
		TextPropCollection b_p_2 = (TextPropCollection)b_p_l.get(1);
		TextPropCollection b_p_3 = (TextPropCollection)b_p_l.get(2);
		TextPropCollection b_p_4 = (TextPropCollection)b_p_l.get(3);
		
		LinkedList b_ch_l = stpb.getCharacterStyles();
		TextPropCollection b_ch_1 = (TextPropCollection)b_ch_l.get(0);
		TextPropCollection b_ch_2 = (TextPropCollection)b_ch_l.get(1);
		TextPropCollection b_ch_3 = (TextPropCollection)b_ch_l.get(2);
		TextPropCollection b_ch_4 = (TextPropCollection)b_ch_l.get(3);

		// CharFlagsTextProp: 3 doesn't have, 4 does
		assertNull(b_ch_3.findByName("char_flags"));
		assertNotNull(b_ch_4.findByName("char_flags"));
		
		// Now add in on 3, should go to front
		assertEquals(2, b_ch_3.getTextPropList().size());
		TextProp new_cftp = b_ch_3.addWithName("char_flags");
		assertEquals(3, b_ch_3.getTextPropList().size());
		assertEquals(new_cftp, b_ch_3.getTextPropList().get(0));
		
		// alignment: 1 does have, 2 doesn't
		assertNotNull(b_p_1.findByName("alignment"));
		assertNull(b_p_2.findByName("alignment"));
		
		// Now add in on 2, should go to the front
		assertEquals(1, b_p_2.getTextPropList().size());
		TextProp new_al = b_p_2.addWithName("alignment");
		assertEquals(2, b_p_2.getTextPropList().size());
		assertEquals(new_al, b_p_2.getTextPropList().get(0));
		
		// This should go at the end
		TextProp new_sa = b_p_2.addWithName("spaceafter");
		assertEquals(3, b_p_2.getTextPropList().size());
		assertEquals(new_sa, b_p_2.getTextPropList().get(2));
		
		// Check we get an error with a made up one
		try {
			b_p_2.addWithName("madeUpOne");
			fail();
		} catch(IllegalArgumentException e) {
			// Good, as expected
		}
	}
	
	/**
	 * Try to recreate an existing StyleTextPropAtom (a) from the empty
	 *  constructor, and setting the required properties
	 */
	public void testCreateAFromScatch() throws Exception {
		// Start with an empty one
		StyleTextPropAtom stpa = new StyleTextPropAtom(54);
		
		// Don't need to touch the paragraph styles
		// Add two more character styles
		LinkedList cs = stpa.getCharacterStyles();
		
		// First char style is boring, and 21 long
		TextPropCollection tpca = (TextPropCollection)cs.get(0);
		tpca.updateTextSize(21);
		
		// Second char style is coloured, 00 00 00 05, and 17 long
		TextPropCollection tpcb = stpa.addCharacterTextPropCollection(17);
		TextProp tpb = tpcb.addWithName("font.color");
		tpb.setValue(0x05000000);
		
		// Third char style is coloured, FF 33 00 FE, and 16 long
		TextPropCollection tpcc = stpa.addCharacterTextPropCollection(16);
		TextProp tpc = tpcc.addWithName("font.color");
		tpc.setValue(0xFE0033FF);
		
		// Should now be the same as data_a
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		stpa.writeOut(baos);
		byte[] b = baos.toByteArray();

		assertEquals(data_a.length, b.length);
		for(int i=0; i<data_a.length; i++) {
			assertEquals(data_a[i],b[i]);
		}
	}

	/**
	 * Try to recreate an existing StyleTextPropAtom (b) from the empty
	 *  constructor, and setting the required properties
	 */
	public void testCreateBFromScatch() throws Exception {
		// Start with an empty one
		StyleTextPropAtom stpa = new StyleTextPropAtom(data_b_text_len);
		
		
		// Need 4 paragraph styles
		LinkedList ps = stpa.getParagraphStyles();
		
		// First is 30 long, left aligned, normal spacing
		TextPropCollection tppa = (TextPropCollection)ps.get(0);
		tppa.updateTextSize(30);
		
		TextProp tp = tppa.addWithName("alignment");
		tp.setValue(0);
		tp = tppa.addWithName("linespacing");
		tp.setValue(80);

		// Second is 28 long, centre aligned and normal spacing
		TextPropCollection tppb = stpa.addParagraphTextPropCollection(28);
		
		tp = tppb.addWithName("linespacing");
		tp.setValue(80);
		
		// Third is 25 long, right aligned and normal spacing
		TextPropCollection tppc = stpa.addParagraphTextPropCollection(25);
		
		tp = tppc.addWithName("alignment");
		tp.setValue(2);
		tp = tppc.addWithName("linespacing");
		tp.setValue(80);
		
		// Forth is left aligned + normal line spacing (despite differing font)
		TextPropCollection tppd = stpa.addParagraphTextPropCollection(97);
		
		tp = tppd.addWithName("alignment");
		tp.setValue(0);
		tp = tppd.addWithName("linespacing");
		tp.setValue(80);
		
		
		// Now do 4 character styles
		LinkedList cs = stpa.getCharacterStyles();
		
		// First is 30 long, bold and font size
		TextPropCollection tpca = (TextPropCollection)cs.get(0);
		tpca.updateTextSize(30);
		
		tp = tpca.addWithName("font.size");
		tp.setValue(20);
		CharFlagsTextProp cftp = (CharFlagsTextProp)
			tpca.addWithName("char_flags");
		assertEquals(0, cftp.getValue());
		cftp.setSubValue(true, CharFlagsTextProp.BOLD_IDX);
		assertEquals(1, cftp.getValue());
		
		// Second is 28 long, blue and italic
		TextPropCollection tpcb = stpa.addCharacterTextPropCollection(28);
		
		tp = tpcb.addWithName("font.size");
		tp.setValue(20);
		tp = tpcb.addWithName("font.color");
		tp.setValue(0x05000000);
		cftp = (CharFlagsTextProp)tpcb.addWithName("char_flags");
		cftp.setSubValue(true, CharFlagsTextProp.ITALIC_IDX);
		assertEquals(2, cftp.getValue());
		
		// Third is 25 long and red
		TextPropCollection tpcc = stpa.addCharacterTextPropCollection(25);
		
		tp = tpcc.addWithName("font.size");
		tp.setValue(20);
		tp = tpcc.addWithName("font.color");
		tp.setValue(0xfe0033ff);
		
		// Fourth is 96 long, underlined and different+bigger font 
		TextPropCollection tpcd = stpa.addCharacterTextPropCollection(96);
		
		tp = tpcd.addWithName("font.size");
		tp.setValue(24);
		tp = tpcd.addWithName("font.index");
		tp.setValue(1);
		cftp = (CharFlagsTextProp)tpcd.addWithName("char_flags");
		cftp.setSubValue(true, CharFlagsTextProp.UNDERLINE_IDX);
		assertEquals(4, cftp.getValue());
		
		// Fifth is 1 long, underlined and different+bigger font + red
		TextPropCollection tpce = stpa.addCharacterTextPropCollection(1);
		
		tp = tpce.addWithName("font.size");
		tp.setValue(24);
		tp = tpce.addWithName("font.index");
		tp.setValue(1);
		tp = tpce.addWithName("font.color");
		tp.setValue(0xfe0033ff);
		cftp = (CharFlagsTextProp)tpce.addWithName("char_flags");
		cftp.setSubValue(true, CharFlagsTextProp.UNDERLINE_IDX);
		assertEquals(4, cftp.getValue());
		
		
		// Check it's as expected
		assertEquals(4, stpa.getParagraphStyles().size());
		assertEquals(5, stpa.getCharacterStyles().size());
		
		// Compare in detail to b
		StyleTextPropAtom stpb = new StyleTextPropAtom(data_b,0,data_b.length);
		stpb.setParentTextSize(data_b_text_len);
		LinkedList psb = stpb.getParagraphStyles();
		LinkedList csb = stpb.getCharacterStyles();
		
		assertEquals(psb.size(), ps.size());
		assertEquals(csb.size(), cs.size());
		
		// Ensure Paragraph Character styles match
		for(int z=0; z<2; z++) {
			LinkedList lla = cs; 
			LinkedList llb = csb;
			int upto = 5;
			if(z == 1) {
				lla = ps;
				llb = psb;
				upto = 4;
			}
			
			for(int i=0; i<upto; i++) {
				TextPropCollection ca = (TextPropCollection)lla.get(i);
				TextPropCollection cb = (TextPropCollection)llb.get(i);
				
				assertEquals(ca.getCharactersCovered(), cb.getCharactersCovered());
				assertEquals(ca.getTextPropList().size(), cb.getTextPropList().size());
				
				for(int j=0; j<ca.getTextPropList().size(); j++) {
					TextProp tpa = (TextProp)ca.getTextPropList().get(j);
					TextProp tpb = (TextProp)cb.getTextPropList().get(j);
					//System.out.println("TP " + i + " " + j + " " + tpa.getName() + "\t" + tpa.getValue() );
					assertEquals(tpa.getName(), tpb.getName());
					assertEquals(tpa.getMask(), tpb.getMask());
					assertEquals(tpa.getWriteMask(), tpb.getWriteMask());
					assertEquals(tpa.getValue(), tpb.getValue());
				}
				
				ByteArrayOutputStream ba = new ByteArrayOutputStream();
				ByteArrayOutputStream bb = new ByteArrayOutputStream();
				
				ca.writeOut(ba);
				cb.writeOut(bb);
				byte[] cab = ba.toByteArray(); 
				byte[] cbb = bb.toByteArray();
				
				assertEquals(cbb.length, cab.length);
				for(int j=0; j<cab.length; j++) {
					//System.out.println("On tp " + z + " " + i + " " + j + "\t" + cab[j] + "\t" + cbb[j]);
					assertEquals(cbb[j], cab[j]);
				}
			}
		}
		

		
		// Check byte level with b
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		stpa.writeOut(baos);
		byte[] b = baos.toByteArray();

		assertEquals(data_b.length, b.length);
		for(int i=0; i<data_b.length; i++) {
			System.out.println(i + "\t" + b[i] + "\t" + data_b[i] + "\t" + Integer.toHexString(b[i]) );
			assertEquals(data_b[i],b[i]);
		}
	}

	public void testWriteA() throws Exception {
		StyleTextPropAtom stpa = new StyleTextPropAtom(data_a,0,data_a.length);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		stpa.writeOut(baos);
		byte[] b = baos.toByteArray();

		assertEquals(data_a.length, b.length);
		for(int i=0; i<data_a.length; i++) {
			assertEquals(data_a[i],b[i]);
		}
	}

	public void testLoadWriteA() throws Exception {
		StyleTextPropAtom stpa = new StyleTextPropAtom(data_a,0,data_a.length);
		stpa.setParentTextSize(data_a_text_len);

		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		stpa.writeOut(baos);
		byte[] b = baos.toByteArray();

		assertEquals(data_a.length, b.length);
		for(int i=0; i<data_a.length; i++) {
			assertEquals(data_a[i],b[i]);
		}
	}


	public void testWriteB() throws Exception {
		StyleTextPropAtom stpb = new StyleTextPropAtom(data_b,0,data_b.length);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		stpb.writeOut(baos);
		byte[] b = baos.toByteArray();

		assertEquals(data_b.length, b.length);
		for(int i=0; i<data_b.length; i++) {
			assertEquals(data_b[i],b[i]);
		}
	}

	public void testLoadWriteB() throws Exception {
		StyleTextPropAtom stpb = new StyleTextPropAtom(data_b,0,data_b.length);
		stpb.setParentTextSize(data_b_text_len);

		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		stpb.writeOut(baos);
		byte[] b = baos.toByteArray();

		assertEquals(data_b.length, b.length);
		for(int i=0; i<data_b.length; i++) {
			//System.out.println(i + "\t" + b[i] + "\t" + data_b[i] + "\t" + Integer.toHexString(b[i]) );
			assertEquals(data_b[i],b[i]);
		}
	}
	
	
	public void testNotEnoughDataProp() throws Exception {
		// We don't have enough data in the record to cover
		//  all the properties the mask says we have
		// Make sure we just do the best we can
		StyleTextPropAtom stpc = new StyleTextPropAtom(data_c,0,data_c.length);
		stpc.setParentTextSize(data_c_text_len);
		
		// If we get here, we didn't break
	}

    /**
     * Check the test data for Bug 40143.
     */
    public void testBug40143() throws Exception {
        StyleTextPropAtom atom = new StyleTextPropAtom(data_d, 0, data_d.length);
        atom.setParentTextSize(data_d_text_len);

        TextPropCollection prprops = (TextPropCollection)atom.getParagraphStyles().getFirst();
        assertEquals(data_d_text_len+1, prprops.getCharactersCovered());
        assertEquals(1, prprops.getTextPropList().size()); //1 property found
        assertEquals(1, prprops.findByName("alignment").getValue());

        TextPropCollection chprops = (TextPropCollection)atom.getCharacterStyles().getFirst();
        assertEquals(data_d_text_len+1, chprops.getCharactersCovered());
        assertEquals(5, chprops.getTextPropList().size()); //5 properties found
        assertEquals(1, chprops.findByName("char_flags").getValue());
        assertEquals(1, chprops.findByName("font.index").getValue());
        assertEquals(20, chprops.findByName("font.size").getValue());
        assertEquals(0, chprops.findByName("asian_or_complex").getValue());
        assertEquals(1, chprops.findByName("char_unknown_2").getValue());
    }

    /**
     * Check the test data for Bug 42677.
     */
     public void test42677() throws Exception {
        int length = 18;
        byte[] data = {0x00, 0x00, (byte)0xA1, 0x0F, 0x28, 0x00, 0x00, 0x00,
                       0x13, 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , (byte)0xF1 , 0x20 , 0x00, 0x00 , 0x00 , 0x00 ,
                       0x22 , 0x20 , 0x00 , 0x00 , 0x64 , 0x00 , 0x00 , 0x00 , 0x00 , (byte)0xFF ,
                       0x00 , 0x00 , 0x13 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x63 , 0x00 ,
                       0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x0F , 0x00
        };
        StyleTextPropAtom stpa = new StyleTextPropAtom(data,0,data.length);
        stpa.setParentTextSize(length);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        stpa.writeOut(baos);
        byte[] b = baos.toByteArray();

        assertEquals(data.length, b.length);
        for(int i=0; i<data.length; i++) {
            assertEquals(data[i],b[i]);
        }

    }
}