Changeset 6014


Ignore:
Timestamp:
03/10/10 06:47:16 (10 years ago)
Author:
callan
Message:

#466 Generalized unit tests for parsed TIFF types (grayscale and RGB implemented). Added a couple general use case tests.

Location:
branches/cleanup/components/bio-formats/test/loci/formats/utests
Files:
4 added
1 edited
1 moved

Legend:

Unmodified
Added
Removed
  • branches/cleanup/components/bio-formats/test/loci/formats/utests/testng.xml

    r5962 r6014  
    2020    </test> 
    2121    <test name="TIFFTests"> 
    22         <groups/> 
     22        <groups> 
     23            <run> 
     24                <exclude name="tiffParserTests"/> 
     25            </run> 
     26        </groups> 
    2327        <classes/> 
    2428        <packages> 
     
    2630        </packages> 
    2731    </test> 
     32    <test name="BaseTIFFParserTest"> 
     33        <parameter name="mockClassName" 
     34                   value="loci.formats.utests.tiff.BaseTiffMock"/> 
     35        <classes> 
     36            <class name="loci.formats.utests.tiff.TiffParserTest"/> 
     37        </classes> 
     38    </test> 
     39    <test name="RGBTIFFParserTest"> 
     40        <parameter name="mockClassName" 
     41                   value="loci.formats.utests.tiff.RGBTiffMock"/> 
     42        <classes> 
     43            <class name="loci.formats.utests.tiff.TiffParserTest"/> 
     44        </classes> 
     45    </test> 
    2846</suite> 
  • branches/cleanup/components/bio-formats/test/loci/formats/utests/tiff/TiffParserTest.java

    r6006 r6014  
    2626 
    2727import java.io.IOException; 
    28 import java.nio.ByteOrder; 
    29  
    30 import loci.common.ByteArrayHandle; 
    31 import loci.common.RandomAccessInputStream; 
     28import java.lang.reflect.Constructor; 
     29 
    3230import loci.formats.FormatException; 
    3331import loci.formats.tiff.IFD; 
    34 import loci.formats.tiff.IFDType; 
    3532import loci.formats.tiff.PhotoInterp; 
    3633import loci.formats.tiff.TiffParser; 
    37 import loci.formats.tiff.TiffRational; 
    3834 
    3935import org.testng.annotations.BeforeMethod; 
     36import org.testng.annotations.Parameters; 
    4037import org.testng.annotations.Test; 
    4138 
     
    4845 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/test/loci/formats/utests/tiff/TiffParserGrayscaleTest.java">SVN</a></dd></dl> 
    4946 */ 
    50 public class TiffParserGrayscaleTest { 
    51  
    52   private ByteArrayHandle handle; 
     47@Test(groups={ "tiffParserTests" }) 
     48public class TiffParserTest { 
     49 
     50  private TiffParser tiffParser; 
    5351   
    54   private RandomAccessInputStream in; 
    55  
    56   private TiffParser tiffParser; 
    57  
    58   private static byte[] TIFF_HEADER = new byte[] { 
    59     0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 
    60   }; 
     52  private BaseTiffMock mock; 
     53 
     54  @Parameters({ "mockClassName" }) 
     55  @BeforeMethod 
     56  public void setUp(String mockClassName) throws Exception { 
     57    Class mockClass = Class.forName(mockClassName); 
     58    Constructor constructor = mockClass.getDeclaredConstructor(); 
     59    mock = (BaseTiffMock) constructor.newInstance(); 
     60    tiffParser = mock.getTiffParser(); 
     61  } 
    6162   
    62   private static final int ENTRY_VALUE_BEGIN_OFFSET = 65535; 
    63  
    64   private static final int IMAGE_WIDTH = 6; 
    65  
    66   private static final int IMAGE_LENGTH = 4; 
    67  
    68   private static final int BITS_PER_SAMPLE = 8; 
    69  
    70   private static final int COMPRESSION = 1; 
    71  
    72   private static final int[] STRIP_OFFSETS = new int[] { 0, 1, 2 };  
    73  
    74   private static final int[] ROWS_PER_STRIP = new int[] { 2, 2, 2 }; 
    75  
    76   private static final TiffRational X_RESOLUTION = new TiffRational(1, 4); 
    77    
    78   private static final TiffRational Y_RESOLUTION = new TiffRational(1, 2); 
    79    
    80   private static final short RESOLUTION_UNIT = 1; 
    81    
    82   private static final int SAMPLES_PER_PIXEL = 1; 
    83  
    84   @BeforeMethod 
    85   public void setUp() throws IOException { 
    86     handle = new ByteArrayHandle(TIFF_HEADER); 
    87     handle.seek(TIFF_HEADER.length); 
    88     handle.setOrder(ByteOrder.LITTLE_ENDIAN); 
    89     long next = ENTRY_VALUE_BEGIN_OFFSET; 
    90     // IFD entry count 
    91     handle.writeShort(10); 
    92     // IMAGE_WIDTH 
    93     writeIFDEntry((short) IFD.IMAGE_WIDTH, IFDType.SHORT, IMAGE_WIDTH); 
    94     // IMAGE_LENGTH 
    95     writeIFDEntry((short) IFD.IMAGE_LENGTH, IFDType.SHORT, IMAGE_LENGTH); 
    96     // BITS_PER_SAMPLE 
    97     writeIFDEntry((short) IFD.BITS_PER_SAMPLE, IFDType.SHORT, 
    98                   BITS_PER_SAMPLE); 
    99     // COMPRESSION 
    100     writeIFDEntry((short) IFD.COMPRESSION, IFDType.SHORT, 
    101                         COMPRESSION); 
    102     // PHOTOMETRIC_INTERPRETATION 
    103     writeIFDEntry((short) IFD.PHOTOMETRIC_INTERPRETATION, IFDType.SHORT, 
    104                   PhotoInterp.RGB.getCode()); 
    105     // STRIP_OFFSETS 
    106     next = writeIFDEntry((short) IFD.STRIP_OFFSETS, IFDType.LONG, 
    107                          STRIP_OFFSETS, next); 
    108     // ROWS_PER_STRIP 
    109     next = writeIFDEntry((short) IFD.ROWS_PER_STRIP, IFDType.LONG, 
    110                          ROWS_PER_STRIP, next); 
    111     // X_RESOLUTION 
    112     next = writeIFDEntry((short) IFD.X_RESOLUTION, IFDType.RATIONAL, 
    113                          X_RESOLUTION, next); 
    114     // Y_RESOLUTION 
    115     next = writeIFDEntry((short) IFD.Y_RESOLUTION, IFDType.RATIONAL, 
    116                          Y_RESOLUTION, next); 
    117     // RESOLUTION_UNIT 
    118     writeIFDEntry((short) IFD.RESOLUTION_UNIT, IFDType.SHORT, 
    119                   RESOLUTION_UNIT); 
    120     // Terminating IFD offset 
    121     handle.writeInt(0); 
    122     in = new RandomAccessInputStream(handle); 
    123     tiffParser = new TiffParser(in); 
    124   } 
    125    
    126   private void writeIFDEntry(short tag, IFDType type, int value) 
    127     throws IOException { 
    128     handle.writeShort(tag);  // IFD entry tag 
    129     handle.writeShort(type.getCode());  // IFD entry type 
    130     handle.writeInt(1);  // IFD entry value count 
    131     handle.writeInt(value);  // The actual value 
    132   } 
    133  
    134   private long writeIFDEntry(short tag, IFDType type, int[] values, 
    135                              long offset) throws IOException { 
    136     handle.writeShort(tag);  // IFD entry tag 
    137     handle.writeShort(type.getCode());  // IFD entry type 
    138     handle.writeInt(values.length);  // IFD entry value count 
    139     handle.writeInt((int) offset); // The offset to the value 
    140     long before = handle.getFilePointer(); 
    141     handle.seek(offset); 
    142     for (int value : values) { 
    143       handle.writeInt(value); 
    144     } 
    145     long after = handle.getFilePointer(); 
    146     handle.seek(before); 
    147     return after; 
    148   } 
    149  
    150   private long writeIFDEntry(short tag, IFDType type, TiffRational values, 
    151                              long offset) throws IOException { 
    152     handle.writeShort(tag);  // IFD entry tag 
    153     handle.writeShort(type.getCode());  // IFD entry type 
    154     handle.writeInt(1);  // IFD entry value count 
    155     handle.writeInt((int) offset); // The offset to the value 
    156     long before = handle.getFilePointer(); 
    157     handle.seek(offset); 
    158     handle.writeInt((int) values.getNumerator()); 
    159     handle.writeInt((int) values.getDenominator()); 
    160     long after = handle.getFilePointer(); 
    161     handle.seek(before); 
    162     return after; 
    163   } 
    164  
    16563  @Test 
    16664  public void testHeader() throws IOException { 
     
    18987    // TODO: Must be called first 
    19088    assertTrue(tiffParser.checkHeader()); 
    191     assertEquals(IMAGE_LENGTH, 
     89    assertEquals(mock.getImageLength(), 
    19290                 tiffParser.getFirstIFD().getImageLength()); 
    19391  } 
     
    19795    // TODO: Must be called first 
    19896    assertTrue(tiffParser.checkHeader()); 
    199     assertEquals(IMAGE_WIDTH, 
     97    assertEquals(mock.getImageWidth(), 
    20098                 tiffParser.getFirstIFD().getImageWidth()); 
    20199  } 
     
    207105    int[] bitsPerSample = tiffParser.getFirstIFD().getBitsPerSample(); 
    208106    assertNotNull(bitsPerSample); 
    209     assertEquals(SAMPLES_PER_PIXEL, bitsPerSample.length); 
    210     assertEquals(BITS_PER_SAMPLE, bitsPerSample[0]); 
     107    assertEquals(mock.getSamplesPerPixel(), bitsPerSample.length); 
     108    short[] BITS_PER_SAMPLE = mock.getBitsPerSample(); 
     109    for (int i = 0; i < BITS_PER_SAMPLE.length; i++) { 
     110      int a = BITS_PER_SAMPLE[i]; 
     111      long b = bitsPerSample[i];  
     112      if (a != b) { 
     113        fail(String.format( 
     114            "Bits per sample offset %d not equivilent: %d != %d", i, a, b)); 
     115      } 
     116    } 
    211117  } 
    212118 
     
    215121    // TODO: Must be called first 
    216122    assertTrue(tiffParser.checkHeader()); 
    217     assertEquals(SAMPLES_PER_PIXEL, 
     123    assertEquals(mock.getSamplesPerPixel(), 
    218124                 tiffParser.getFirstIFD().getSamplesPerPixel()); 
    219125  } 
     
    225131    long[] stripOffsets = tiffParser.getFirstIFD().getStripOffsets(); 
    226132    assertNotNull(stripOffsets); 
     133    int[] STRIP_OFFSETS = mock.getStripOffsets(); 
    227134    assertEquals(STRIP_OFFSETS.length, stripOffsets.length); 
    228135    for (int i = 0; i < STRIP_OFFSETS.length; i++) { 
     
    242149    long[] rowsPerStrip = tiffParser.getFirstIFD().getRowsPerStrip(); 
    243150    assertNotNull(rowsPerStrip); 
     151    int[] ROWS_PER_STRIP = mock.getRowsPerStrip(); 
    244152    assertEquals(ROWS_PER_STRIP.length, rowsPerStrip.length); 
    245153    for (int i = 0; i < ROWS_PER_STRIP.length; i++) { 
     
    258166    assertTrue(tiffParser.checkHeader()); 
    259167    int tag = IFD.X_RESOLUTION; 
    260     assertTrue(X_RESOLUTION.equals( 
     168    assertTrue(mock.getXResolution().equals( 
    261169        tiffParser.getFirstIFD().getIFDRationalValue(tag))); 
    262170  } 
     
    267175    assertTrue(tiffParser.checkHeader()); 
    268176    int tag = IFD.Y_RESOLUTION; 
    269     assertTrue(Y_RESOLUTION.equals( 
     177    assertTrue(mock.getYResolution().equals( 
    270178        tiffParser.getFirstIFD().getIFDRationalValue(tag))); 
    271179  } 
     
    276184    assertTrue(tiffParser.checkHeader()); 
    277185    int tag = IFD.RESOLUTION_UNIT; 
    278     assertEquals(RESOLUTION_UNIT, 
     186    assertEquals(mock.getResolutionUnit(), 
    279187                 tiffParser.getFirstIFD().getIFDIntValue(tag)); 
    280188  } 
    281189 
    282   // TODO: Test non-uniform rows per strip exception 
    283   // TODO: Test bits per sample array length != samples per pixel exception 
     190  @Test(expectedExceptions={ FormatException.class }) 
     191  public void testNonUniformRowsPerStrip() throws IOException, FormatException { 
     192    mock = new NonUniformRowsPerStripMock(); 
     193    tiffParser = mock.getTiffParser(); 
     194    assertTrue(tiffParser.checkHeader()); 
     195    tiffParser.getFirstIFD().getRowsPerStrip(); 
     196  } 
     197 
     198  @Test(expectedExceptions={ FormatException.class }) 
     199  public void testBitsPerSampleMismatch() throws IOException, FormatException { 
     200    mock = new BitsPerSampleSamplesPerPixelMismatchMock(); 
     201    tiffParser = mock.getTiffParser(); 
     202    assertTrue(tiffParser.checkHeader()); 
     203    tiffParser.getFirstIFD().getBitsPerSample(); 
     204  } 
     205 
    284206  // TODO: Test wrong type exceptions 
    285207} 
Note: See TracChangeset for help on using the changeset viewer.