Changeset 6851


Ignore:
Timestamp:
08/27/10 14:04:58 (9 years ago)
Author:
melissa
Message:
  • Added more informative logging.
  • Make sure that tests fail if files were not configured.
Location:
branches/junit-test-suite/components/test-suite/src/loci/tests/junit
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/junit-test-suite/components/test-suite/src/loci/tests/junit/ConfigurationTree.java

    r6850 r6851  
    212212  } 
    213213 
     214  /** Returns whether or not the current file was actually configured. */ 
     215  public boolean isConfigured() { 
     216    return pos != null; 
     217  } 
     218 
    214219  /** Sets the active series. */ 
    215220  public void setSeries(int series) { 
  • branches/junit-test-suite/components/test-suite/src/loci/tests/junit/FormatReaderTest.java

    r6850 r6851  
    4343import loci.common.services.ServiceException; 
    4444import loci.common.services.ServiceFactory; 
     45import loci.formats.ChannelFiller; 
     46import loci.formats.ChannelSeparator; 
    4547import loci.formats.FileStitcher; 
    4648import loci.formats.FormatException; 
     
    4850import loci.formats.IFormatReader; 
    4951import loci.formats.ImageReader; 
     52import loci.formats.MinMaxCalculator; 
    5053import loci.formats.ReaderWrapper; 
    5154import loci.formats.gui.AWTImageTools; 
     
    6265import org.junit.runners.Parameterized; 
    6366 
     67import org.slf4j.Logger; 
     68import org.slf4j.LoggerFactory; 
     69 
    6470import static org.junit.Assert.*; 
    6571import static org.junit.Assume.*; 
     
    7379  private static final String BASE_DIR_PROP = "junit.directory"; 
    7480  private static final String MULTIPLIER_PROP = "junit.multiplier"; 
     81  private static final Logger LOGGER = 
     82    LoggerFactory.getLogger(FormatReaderTest.class); 
    7583 
    7684  // -- Static fields -- 
     
    107115    } 
    108116    catch (DependencyException e) { 
    109       // TODO : log this 
     117      LOGGER.warn("", e); 
    110118    } 
    111119  } 
     
    122130    IFormatReader bufferedImageReader = new BufferedImageReader(); 
    123131    for (Object file : files) { 
    124       // TODO : we could add many more wrapper combinations here 
    125132      rtn.add(new Object[] {fileReader, file}); 
    126133      rtn.add(new Object[] {bufferedImageReader, file}); 
     
    141148        } 
    142149        catch (ServiceException e) { 
    143           // TODO : log this 
     150          LOGGER.warn("", e); 
    144151        } 
    145152        reader.setMetadataStore(store); 
     
    154161  public void testSeriesCount() { 
    155162    assumeTrue(config.isTestable()); 
    156     assumeTrue(reader.getCurrentFile().equals(file)); 
    157     assertEquals("Series counts do not match", 
     163    assertTrue(file, config.isConfigured()); 
     164    assumeTrue(reader.getCurrentFile().equals(file)); 
     165    assertEquals(file + ": series counts do not match", 
    158166      config.getSeriesCount(), reader.getSeriesCount()); 
    159167  } 
     
    162170  public void testCoreMetadata() { 
    163171    assumeTrue(config.isTestable()); 
     172    assertTrue(file, config.isConfigured()); 
    164173    assumeTrue(reader.getCurrentFile().equals(file)); 
    165174    for (int series=0; series<reader.getSeriesCount(); series++) { 
    166       String message = "Series #" + series; 
     175      String message = file + ": series #" + series; 
    167176      config.setSeries(series); 
    168177      reader.setSeries(series); 
     
    191200  public void testSaneUsedFiles() { 
    192201    assumeTrue(config.isTestable()); 
     202    assertTrue(file, config.isConfigured()); 
    193203    assumeTrue(reader.getCurrentFile().equals(file)); 
    194204 
    195205    String[] base = reader.getUsedFiles(); 
    196206    if (base.length == 1) { 
    197       assertEquals(base[0], file); 
     207      assertEquals(file, base[0], file); 
    198208      return; 
    199209    } 
     
    201211    Arrays.sort(base); 
    202212 
    203     // TODO : this should match the arbitrary wrapper chain 
    204     IFormatReader r = new ImageReader(); 
     213    // copy the current IFormatReader 
     214 
     215    IFormatReader r = null; 
     216    if (reader instanceof FileStitcher) { 
     217      ReaderWrapper wrapper = 
     218        (ReaderWrapper) ((FileStitcher) reader).getReader(); 
     219      try { 
     220        r = new FileStitcher(wrapper.duplicate(null)); 
     221      } 
     222      catch (Exception e) { 
     223        fail(file + ": " + e.getMessage()); 
     224      } 
     225    } 
     226    if (reader instanceof ImageReader) { 
     227      r = new ImageReader(); 
     228    } 
     229    if (reader instanceof ReaderWrapper) { 
     230      try { 
     231        r = ((ReaderWrapper) reader).duplicate(null); 
     232      } 
     233      catch (Exception e) { 
     234        fail(file + ": " + e.getMessage()); 
     235      } 
     236    } 
    205237 
    206238    for (String f : base) { 
     
    211243        String[] comp = r.getUsedFiles(); 
    212244        Arrays.sort(comp); 
    213         assertArrayEquals(f, comp, base); 
     245        assertArrayEquals(file + ": " + f, comp, base); 
    214246        r.close(); 
    215247      } 
     
    217249      catch (IOException e) { exc = e; } 
    218250      if (exc != null) { 
    219         fail(f + " (" + exc.getMessage() + ")"); 
     251        fail(file + ": " + f + " (" + exc.getMessage() + ")"); 
    220252      } 
    221253    } 
     
    225257  public void testOMEXMLConsistency() { 
    226258    assumeTrue(config.isTestable()); 
     259    assertTrue(file, config.isConfigured()); 
    227260    assumeTrue(reader.getCurrentFile().equals(file)); 
    228261 
     
    234267 
    235268      String type = FormatTools.getPixelTypeString(reader.getPixelType()); 
    236       String message = "Series " + i; 
     269      String message = file + ": series " + i; 
    237270 
    238271      assertEquals(message, 
     
    260293        } 
    261294        catch (FormatException e) { 
    262           // TODO : log this 
     295          LOGGER.warn("", e); 
    263296        } 
    264297        catch (IOException e) { 
    265           // TODO : log this 
     298          LOGGER.warn("", e); 
    266299        } 
    267300      } 
     
    281314  public void testPixelsHashes() { 
    282315    assumeTrue(config.isTestable()); 
     316    assertTrue(file, config.isConfigured()); 
    283317    assumeTrue(reader.getCurrentFile().equals(file)); 
    284318 
     
    291325        String expectedMD5 = config.getMD5(); 
    292326 
    293         assertEquals("Series " + i, md5, expectedMD5); 
     327        assertEquals(file + ": series " + i, md5, expectedMD5); 
    294328      } 
    295329      catch (FormatException e) { 
    296         fail("Series " + i + " (" + e.getMessage() + ")"); 
     330        fail(file + ": series " + i + " (" + e.getMessage() + ")"); 
    297331      } 
    298332      catch (IOException e) { 
    299         fail("Series " + i + " (" + e.getMessage() + ")"); 
     333        fail(file + ": series " + i + " (" + e.getMessage() + ")"); 
    300334      } 
    301335    } 
     
    305339  public void testBufferedImageDimensions() { 
    306340    assumeTrue(config.isTestable()); 
     341    assertTrue(file, config.isConfigured()); 
    307342    assumeTrue(reader.getCurrentFile().equals(file)); 
    308343    assumeTrue(reader instanceof BufferedImageReader); 
     
    322357          b = ((BufferedImageReader) reader).openImage(image); 
    323358        } 
    324         catch (FormatException e) { 
    325           fail("Series " + i + " Plane " + image + " (" + e.getMessage() + ")"); 
    326         } 
    327         catch (IOException e) { 
    328           fail("Series " + i + " Plane " + image + " (" + e.getMessage() + ")"); 
    329         } 
    330  
    331         assertEquals(x, b.getWidth()); 
    332         assertEquals(y, b.getHeight()); 
    333         assertEquals(c, b.getRaster().getNumBands()); 
    334         assertEquals(type, AWTImageTools.getPixelType(b)); 
     359        catch (Exception e) { 
     360          fail(file + ": series " + i + " Plane " + image + 
     361            " (" + e.getMessage() + ")"); 
     362        } 
     363 
     364        assertEquals(file, x, b.getWidth()); 
     365        assertEquals(file, y, b.getHeight()); 
     366        assertEquals(file, c, b.getRaster().getNumBands()); 
     367        assertEquals(file, type, AWTImageTools.getPixelType(b)); 
    335368      } 
    336369    } 
     
    340373  public void testByteArrayDimensions() { 
    341374    assumeTrue(config.isTestable()); 
     375    assertTrue(file, config.isConfigured()); 
    342376    assumeTrue(reader.getCurrentFile().equals(file)); 
    343377    assumeTrue(!(reader instanceof BufferedImageReader)); 
     
    358392          b = reader.openBytes(image); 
    359393        } 
    360         catch (FormatException e) { 
    361           fail("Series " + i + " Plane " + image + " (" + e.getMessage() + ")"); 
    362         } 
    363         catch (IOException e) { 
    364           fail("Series " + i + " Plane " + image + " (" + e.getMessage() + ")"); 
    365         } 
    366         assertEquals( 
    367           "Series " + i + ", Plane " + image, b.length, expectedByteCount); 
     394        catch (Exception e) { 
     395          fail(file + ": series " + i + " Plane " + image + 
     396            " (" + e.getMessage() + ")"); 
     397        } 
     398        assertEquals(file + ": series " + i + ", Plane " + image, 
     399          b.length, expectedByteCount); 
    368400      } 
    369401    } 
     
    373405  public void testThumbnailBufferedImageDimensions() { 
    374406    assumeTrue(config.isTestable()); 
     407    assertTrue(file, config.isConfigured()); 
    375408    assumeTrue(reader.getCurrentFile().equals(file)); 
    376409    assumeTrue(reader instanceof BufferedImageReader); 
     
    388421        b = ((BufferedImageReader) reader).openThumbImage(0); 
    389422      } 
    390       catch (FormatException e) { 
    391         fail("Series " + i + " (" + e.getMessage() + ")"); 
    392       } 
    393       catch (IOException e) { 
    394         fail("Series " + i + " (" + e.getMessage() + ")"); 
    395       } 
    396       String message = "Series " + i; 
     423      catch (Exception e) { 
     424        fail(file + ": series " + i + " (" + e.getMessage() + ")"); 
     425      } 
     426      String message = file + ": series " + i; 
    397427      assertEquals(message, x, b.getWidth()); 
    398428      assertEquals(message, y, b.getHeight()); 
     
    410440  public void testThumbnailByteArrayDimensions() { 
    411441    assumeTrue(config.isTestable()); 
     442    assertTrue(file, config.isConfigured()); 
    412443    assumeTrue(reader.getCurrentFile().equals(file)); 
    413444    assumeTrue(!(reader instanceof BufferedImageReader)); 
     
    425456        b = reader.openThumbBytes(0); 
    426457      } 
    427       catch (FormatException e) { 
    428         fail("Series " + i + " (" + e.getMessage() + ")"); 
    429       } 
    430       catch (IOException e) { 
    431         fail("Series " + i + " (" + e.getMessage() + ")"); 
    432       } 
    433       assertEquals("Series " + i, b.length, expected); 
     458      catch (Exception e) { 
     459        fail(file + ": series " + i + " (" + e.getMessage() + ")"); 
     460      } 
     461      assertEquals(file + ": series " + i, b.length, expected); 
    434462    } 
    435463  } 
     
    440468  public void testImageCount() { 
    441469    assumeTrue(config.isTestable()); 
     470    assertTrue(file, config.isConfigured()); 
    442471    assumeTrue(reader.getCurrentFile().equals(file)); 
    443472 
     
    448477      int c = reader.getEffectiveSizeC(); 
    449478      int t = reader.getSizeT(); 
    450       assertEquals("Series " + i, imageCount, z * c * t); 
     479      assertEquals(file + ": series " + i, imageCount, z * c * t); 
    451480    } 
    452481  } 
     
    455484  public void testSaneOMEXML() { 
    456485    assumeTrue(config.isTestable()); 
     486    assertTrue(file, config.isConfigured()); 
    457487    assumeTrue(reader.getCurrentFile().equals(file)); 
    458488 
     
    470500      int samplesPerPixel = meta.getChannelSamplesPerPixel(i, 0).getValue(); 
    471501 
    472       String message = "Series " + i; 
     502      String message = file + ": series " + i; 
    473503      assertEquals(message, sizeC, nChannels * samplesPerPixel); 
    474504 
     
    488518  public void testValidOMEXML() { 
    489519    assumeTrue(config.isTestable()); 
     520    assertTrue(file, config.isConfigured()); 
    490521    assumeTrue(reader.getCurrentFile().equals(file)); 
    491522 
     
    495526    try { 
    496527      String xml = omexmlService.getOMEXML(meta); 
    497       assertTrue(omexmlService.validateOMEXML(xml)); 
     528      assertTrue(file, omexmlService.validateOMEXML(xml)); 
    498529    } 
    499530    catch (ServiceException e) { 
    500       fail(e.getMessage()); 
     531      fail(file + ": " + e.getMessage()); 
    501532    } 
    502533  } 
     
    510541  public void testPerformance() { 
    511542    assumeTrue(config.isTestable()); 
     543    assertTrue(file, config.isConfigured()); 
    512544    assumeTrue(reader.getCurrentFile().equals(file)); 
    513545 
     
    515547    double properTime = config.getTimePerPlane(); 
    516548 
    517     assertTrue("Missing memory configuration", properMem > 0); 
    518     assertTrue("Missing timing configuration", properTime > 0); 
     549    assertTrue(file + ": missing memory configuration", properMem > 0); 
     550    assertTrue(file + ": missing timing configuration", properTime > 0); 
    519551 
    520552    Runtime r = Runtime.getRuntime(); 
     
    533565        } 
    534566        catch (Exception e) { 
    535           fail("Series " + i + ", plane " + j + ": " + e.getMessage()); 
     567          fail(file + ": series " + i + ", plane " + j + ": " + e.getMessage()); 
    536568        } 
    537569      } 
     
    543575    int actualMem = (int) ((m2 - m1) >> 20); 
    544576 
    545     assertTrue(actualTime - timeMultiplier * properTime <= 20.0); 
    546     assertTrue(actualMem <= properMem); 
     577    assertTrue(file, actualTime - timeMultiplier * properTime <= 50.0); 
     578    assertTrue(file, actualMem <= properMem); 
    547579  } 
    548580 
     
    552584  public void testIsThisType() { 
    553585    assumeTrue(config.isTestable()); 
     586    assertTrue(file, config.isConfigured()); 
    554587    assumeTrue(reader.getCurrentFile().equals(file)); 
    555588 
     
    563596      } 
    564597      catch (Exception e) { 
    565         fail(e.getMessage()); 
     598        fail(file + ": " + e.getMessage()); 
    566599      } 
    567600    } 
     
    590623 
    591624        String checkName = TestTools.shortClassName(check); 
    592         assertEquals(checkName, result, baseName.equals(checkName)); 
     625        assertEquals(file + ": " + checkName, 
     626          result, baseName.equals(checkName)); 
    593627      } 
    594628    } 
Note: See TracChangeset for help on using the changeset viewer.