Changeset 7371


Ignore:
Timestamp:
12/09/10 06:57:48 (9 years ago)
Author:
callan
Message:

Extended OMERO openBytes() test case (See  omero:#3627)

  • Go through every series of a given file
  • Test reading quarters (top-left, top-right, bottom-left, bottom-right)
Location:
trunk/components/test-suite/src/loci/tests/testng
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/test-suite/src/loci/tests/testng/OmeroOpenBytesTest.java

    r7336 r7371  
    6262  private int imageCount; 
    6363 
     64  private int seriesCount; 
     65 
    6466  private int sizeX; 
    6567 
     
    7981 
    8082  private int bottomHalfSize; 
     83 
     84  private int topLeftQuarterSize; 
     85 
     86  private int topRightQuarterSize; 
     87 
     88  private int bottomLeftQuarterSize; 
     89 
     90  private int bottomRightQuarterSize; 
    8191 
    8292  @Parameters({"id"}) 
     
    8898    reader = new MinMaxCalculator(reader); 
    8999    reader.setId(id); 
     100  } 
     101 
     102  private void assertBlock(int blockSize, int posX, int posY, 
     103                           int width, int height) throws Exception { 
     104    byte[] plane = new byte[planeSize]; 
     105    byte[] buf = new byte[blockSize]; 
     106    String planeDigest, bufDigest; 
     107    for (int i = 0; i < imageCount; i++) { 
     108      // Read the data as a full plane 
     109      reader.openBytes(i, plane); 
     110      // Read the data as a block 
     111      try { 
     112        reader.openBytes(i, buf, posX, posY, width, height); 
     113      } 
     114      catch (Exception e) { 
     115        throw new RuntimeException(String.format( 
     116            "openBytes(i:%d, buf.length:%d, x:%d, y:%d, w:%d, h:%d) " + 
     117            "[sizeX: %d sizeY:%d bpp:%d] threw exception!", 
     118            i, buf.length, posX, posY, width, height, sizeX, sizeY, bpp), e); 
     119      } 
     120      // Compare hash digests 
     121      planeDigest = TestTools.md5( 
     122          plane, sizeX, sizeY, posX, posY, width, height, bpp); 
     123      bufDigest = TestTools.md5(buf, 0, width * height * bpp); 
     124      if (!planeDigest.equals(bufDigest)) { 
     125        fail(String.format("MD5:%d len:%d %s != %s", 
     126            i, blockSize, planeDigest, bufDigest)); 
     127      } 
     128      // Update offsets, etc. 
     129      posY += height; 
     130    } 
     131  } 
     132 
     133  private void assertRows(int blockSize) throws Exception { 
     134    for (int series = 0; series < seriesCount; series++) { 
     135      assertSeries(series); 
     136      byte[] plane = new byte[planeSize]; 
     137      byte[] buf = new byte[blockSize]; 
     138      int maximumRowCount = buf.length / bpp / sizeX; 
     139      String planeDigest, bufDigest; 
     140      int pixelsToRead = sizeX * sizeY; 
     141      int width = sizeX, height, posX = 0, posY = 0, actualBufSize; 
     142      for (int i = 0; i < imageCount; i++) { 
     143        // Read the data as a full plane 
     144        reader.openBytes(i, plane); 
     145        int offset = 0; 
     146        while(pixelsToRead > 0) { 
     147          // Prepare our read metadata 
     148          height = maximumRowCount; 
     149          if ((posY + height) > sizeY) 
     150          { 
     151            height = sizeY - posY; 
     152          } 
     153          actualBufSize = bpp * height * width; 
     154          // Read the data as a block 
     155          try { 
     156            reader.openBytes(i, buf, posX, posY, width, height); 
     157          } 
     158          catch (Exception e) { 
     159            throw new RuntimeException(String.format( 
     160                "openBytes(i:%d, buf.length:%d, x:%d, y:%d, w:%d, h:%d) " + 
     161                "[sizeX: %d sizeY:%d bpp:%d] threw exception!", 
     162                i, buf.length, posX, posY, width, height, sizeX, sizeY, bpp), e); 
     163          } 
     164          // Compare hash digests 
     165          planeDigest = TestTools.md5(plane, offset, actualBufSize); 
     166          bufDigest = TestTools.md5(buf, 0, actualBufSize); 
     167          if (!planeDigest.equals(bufDigest)) { 
     168            fail(String.format("MD5:%d offset:%d len:%d %s != %s", 
     169                i, offset, actualBufSize, planeDigest, bufDigest)); 
     170          } 
     171          // Update offsets, etc. 
     172          offset += actualBufSize; 
     173          posY += height; 
     174          pixelsToRead -= height * width; 
     175        } 
     176      } 
     177    } 
     178  } 
     179 
     180  private void assertSeries(int series) { 
     181    reader.setSeries(series); 
    90182    sizeX = reader.getSizeX(); 
    91183    sizeY = reader.getSizeY(); 
     
    94186    sizeT = reader.getSizeT(); 
    95187    imageCount = reader.getImageCount(); 
     188    seriesCount = reader.getSeriesCount(); 
    96189    bpp = FormatTools.getBytesPerPixel(reader.getPixelType()); 
    97190    planeSize = sizeX * sizeY * bpp; 
    98191    topHalfSize = (sizeY / 2) * sizeX * bpp; 
    99192    bottomHalfSize = (sizeY - (sizeY / 2)) * sizeX * bpp; 
    100   } 
    101  
    102   private void assertBlock(int blockSize) throws Exception { 
    103     byte[] plane = new byte[planeSize]; 
    104     byte[] buf = new byte[blockSize]; 
    105     int maximumRowCount = buf.length / bpp / sizeX; 
    106     String planeDigest, bufDigest; 
    107     int pixelsToRead = sizeX * sizeY; 
    108     int width = sizeX, height, posX = 0, posY = 0, actualBufSize; 
    109     for (int i = 0; i < imageCount; i++) { 
    110       // Read the data as a full plane 
    111       reader.openBytes(i, plane); 
    112       int offset = 0; 
    113       while(pixelsToRead > 0) { 
    114         // Prepare our read metadata 
    115         height = maximumRowCount; 
    116         if ((posY + height) > sizeY) 
    117         { 
    118             height = sizeY - posY; 
    119         } 
    120         actualBufSize = bpp * height * width; 
    121         // Read the data as a block 
    122         try { 
    123           reader.openBytes(i, buf, posX, posY, width, height); 
    124         } 
    125         catch (Exception e) { 
    126           throw new RuntimeException(String.format( 
    127               "openBytes(i:%d, buf.length:%d, x:%d, y:%d, w:%d, h:%d) " + 
    128               "[sizeX: %d sizeY:%d bpp:%d] threw exception!", 
    129               i, buf.length, posX, posY, width, height, sizeX, sizeY, bpp), e); 
    130         } 
    131         // Compare hash digests 
    132         planeDigest = TestTools.md5(plane, offset, actualBufSize); 
    133         bufDigest = TestTools.md5(buf, 0, actualBufSize); 
    134         if (!planeDigest.equals(bufDigest)) { 
    135           fail(String.format("MD5:%d offset:%d len:%d %s != %s", 
    136               i, offset, actualBufSize, planeDigest, bufDigest)); 
    137         } 
    138         // Update offsets, etc. 
    139         offset += actualBufSize; 
    140         posY += height; 
    141         pixelsToRead -= height * width; 
    142       } 
    143     } 
     193    topLeftQuarterSize = (sizeY / 2) * (sizeX / 2) * bpp; 
     194    topRightQuarterSize = (sizeY / 2) * (sizeX - (sizeX / 2)) * bpp; 
     195    bottomLeftQuarterSize = (sizeY - (sizeY / 2)) * (sizeX / 2) * bpp; 
     196    bottomRightQuarterSize = 
     197      (sizeY - (sizeY / 2)) * (sizeX - (sizeX / 2)) * bpp; 
    144198  } 
    145199 
     
    151205  @Test 
    152206  public void testOpenBytesPlane() throws Exception { 
    153     byte[] plane = new byte[planeSize]; 
    154     for (int i = 0; i < reader.getImageCount(); i++) { 
    155       reader.openBytes(i, plane); 
     207    for (int series = 0; series < seriesCount; series++) { 
     208      assertSeries(series); 
     209      byte[] plane = new byte[planeSize]; 
     210      for (int i = 0; i < reader.getImageCount(); i++) { 
     211        reader.openBytes(i, plane); 
     212      } 
    156213    } 
    157214  } 
     
    159216  @Test 
    160217  public void testOpenBytesHalfPlane() throws Exception { 
    161     byte[] plane = new byte[planeSize]; 
    162     byte[] topHalfPlane = new byte[topHalfSize]; 
    163     byte[] bottomHalfPlane = new byte[bottomHalfSize]; 
    164     String planeDigest, halfPlaneDigest; 
    165     for (int i = 0; i < imageCount; i++) { 
    166       // Check the digest for the first half of the plane against a full plane 
    167       reader.openBytes(i, plane); 
    168       reader.openBytes(i, topHalfPlane, 0, 0, sizeX, sizeY / 2); 
    169       planeDigest = TestTools.md5(plane, 0, topHalfSize); 
    170       halfPlaneDigest = TestTools.md5(topHalfPlane, 0, topHalfSize); 
    171       if (!planeDigest.equals(halfPlaneDigest)) { 
    172         fail(String.format("First half MD5:%d %s != %s", 
    173             i, planeDigest, halfPlaneDigest)); 
    174       } 
    175       // Check the digest for the second half of the plane against a full plane 
    176       reader.openBytes(i, bottomHalfPlane, 0, sizeY / 2, sizeX, 
    177         sizeY - (sizeY / 2)); 
    178       planeDigest = TestTools.md5(plane, topHalfSize, bottomHalfSize); 
    179       halfPlaneDigest = TestTools.md5(bottomHalfPlane, 0, bottomHalfSize); 
    180       if (!planeDigest.equals(halfPlaneDigest)) { 
    181         fail(String.format("Second half MD5:%d %s != %s", 
    182             i, planeDigest, halfPlaneDigest)); 
    183       } 
     218    for (int series = 0; series < seriesCount; series++) { 
     219      assertSeries(series); 
     220      byte[] plane = new byte[planeSize]; 
     221      byte[] topHalfPlane = new byte[topHalfSize]; 
     222      byte[] bottomHalfPlane = new byte[bottomHalfSize]; 
     223      String planeDigest, halfPlaneDigest; 
     224      for (int i = 0; i < imageCount; i++) { 
     225        // Check the digest for the first half of the plane against a full 
     226        // plane 
     227        reader.openBytes(i, plane); 
     228        reader.openBytes(i, topHalfPlane, 0, 0, sizeX, sizeY / 2); 
     229        planeDigest = TestTools.md5(plane, 0, topHalfSize); 
     230        halfPlaneDigest = TestTools.md5(topHalfPlane, 0, topHalfSize); 
     231        if (!planeDigest.equals(halfPlaneDigest)) { 
     232          fail(String.format("First half MD5:%d %s != %s", 
     233              i, planeDigest, halfPlaneDigest)); 
     234        } 
     235        // Check the digest for the second half of the plane against a full 
     236        // plane 
     237        reader.openBytes(i, bottomHalfPlane, 0, sizeY / 2, sizeX, 
     238            sizeY - (sizeY / 2)); 
     239        planeDigest = TestTools.md5(plane, topHalfSize, bottomHalfSize); 
     240        halfPlaneDigest = TestTools.md5(bottomHalfPlane, 0, bottomHalfSize); 
     241        if (!planeDigest.equals(halfPlaneDigest)) { 
     242          fail(String.format("Second half MD5:%d %s != %s", 
     243              i, planeDigest, halfPlaneDigest)); 
     244        } 
     245      } 
     246    } 
     247  } 
     248 
     249  @Test 
     250  public void testQuartersActualSize() throws Exception { 
     251    for (int series = 0; series < seriesCount; series++) { 
     252      assertSeries(series); 
     253      assertBlock(topLeftQuarterSize, 0, 0, sizeX / 2, sizeY / 2); 
     254      assertBlock(topRightQuarterSize, sizeX / 2, 0, 
     255                  sizeX - (sizeX / 2), sizeY / 2); 
     256      assertBlock(bottomLeftQuarterSize, 0, sizeY / 2, 
     257                  sizeX / 2, (sizeY - (sizeY / 2))); 
     258      assertBlock(bottomRightQuarterSize, sizeX / 2, sizeY / 2, 
     259                  sizeX - (sizeX / 2), sizeY - (sizeY / 2)); 
     260    } 
     261  } 
     262 
     263  @Test 
     264  public void testQuartersTwiceActualSize() throws Exception { 
     265    for (int series = 0; series < seriesCount; series++) { 
     266      assertSeries(series); 
     267      assertBlock(topLeftQuarterSize * 2, 0, 0, sizeX / 2, sizeY / 2); 
     268      assertBlock(topRightQuarterSize * 2, sizeX / 2, 0, 
     269                  sizeX - (sizeX / 2), sizeY / 2); 
     270      assertBlock(bottomLeftQuarterSize * 2, 0, sizeY / 2, 
     271                  sizeX / 2, (sizeY - (sizeY / 2))); 
     272      assertBlock(bottomRightQuarterSize * 2, sizeX / 2, sizeY / 2, 
     273                  sizeX - (sizeX / 2), sizeY - (sizeY / 2)); 
    184274    } 
    185275  } 
     
    187277  @Test 
    188278  public void testOpenBytesBlocksByRow512KB() throws Exception { 
    189     assertBlock(524288); 
     279    assertRows(524288); 
    190280  } 
    191281 
    192282  @Test 
    193283  public void testOpenBytesBlocksByRow1MB() throws Exception { 
    194     assertBlock(1048576); 
     284    assertRows(1048576); 
    195285  } 
    196286 
    197287  @Test 
    198288  public void testOpenBytesBlocksByRowPlaneSize() throws Exception { 
    199     assertBlock(sizeX * sizeY * bpp); 
     289    assertRows(sizeX * sizeY * bpp); 
    200290  } 
    201291 
  • trunk/components/test-suite/src/loci/tests/testng/TestTools.java

    r7313 r7371  
    104104 
    105105  /** Calculate the MD5 of a byte array. */ 
     106  public static String md5(byte[] b, int sizeX, int sizeY, int posX, int posY, 
     107                           int width, int height, int bpp) { 
     108    try { 
     109      MessageDigest md = MessageDigest.getInstance("MD5"); 
     110      md.reset(); 
     111      int offset = 0; 
     112      for (int i = 0; i < height; i++) { 
     113        offset = (((posY + i) * sizeX) + posX) * bpp; 
     114        md.update(b, offset, width * bpp); 
     115      } 
     116      byte[] digest = md.digest(); 
     117      return DataTools.bytesToHex(digest); 
     118    } 
     119    catch (NoSuchAlgorithmException e) { } 
     120    return null; 
     121  } 
     122 
     123  /** Calculate the MD5 of a byte array. */ 
    106124  public static String md5(byte[] b, int offset, int len) { 
    107125    try { 
Note: See TracChangeset for help on using the changeset viewer.