if (holder.isAvailable()) basic = holder.get();
public int compare (@Nonnull final MetadataItemHolder<?> holder1, @Nonnull final MetadataItemHolder<?> holder2) { final Date date1 = holder1.getLatestModificationTime(); final Date date2 = holder2.getLatestModificationTime(); if (date1 == null) { return (date2 == null) ? 0 : +1; } if (date2 == null) { return -1; } return -date1.compareTo(date2); } };
@Test public void testTypicalImportPattern() throws NoSuchMetadataTypeException { final Collection<Class<?>> itemClasses = metadata.getItemClasses(); for (final Class<?> itemClass : itemClasses) { final List<MetadataItemHolder<?>> holders = new ArrayList<MetadataItemHolder<?>>(metadata.findOrCreateItems(itemClass, StorageType.EXTERNAL)); Collections.reverse(holders); for (final MetadataItemHolder<?> holder : holders) { final int n = metadata.storeItem(holder, StorageType.INTERNAL, ReplaceOption.REPLACE); assertEquals((holder.get() instanceof MockItem1) ? 1 : 0, n); } } assertEquals(2, MetadataItemSinkMock1a.dataObjects.size()); assertEquals(2, MetadataItemSinkMock1a.holders.size()); assertEquals(2, MetadataItemSinkMock1a.storeOptions.size()); assertEquals(MetadataItemSourceMock1a.DATE, MetadataItemSinkMock1a.holders.get(0).getLatestModificationTime()); assertEquals(MetadataItemSourceMock1b.DATE, MetadataItemSinkMock1a.holders.get(1).getLatestModificationTime()); // most recent last }
@Test public void testLastestModificationTimeIsUpdated() throws Exception { final DataObject dataObject = DataObject.find(FileUtil.createMemoryFileSystem().getRoot().createData("goodfile")); final MetadataItemHolder<TIFF> holder = tiffProvider.findOrCreateItems(dataObject, EXTERNAL).iterator().next(); assertNotNull(holder); final Date timestamp1 = holder.getLatestModificationTime(); assertTrue(holder.isAvailable()); Thread.sleep(1000); final Date now = new Date(); holder.get().setArtist("new artist"); final Date timestamp2 = holder.getLatestModificationTime(); assertTrue(timestamp2.getTime() - now.getTime() < 50); assertNotSame(timestamp1, timestamp2); } }
/*************************************************************************** * * **************************************************************************/ public void bind (@Nonnull final MetadataItemHolder<? extends Bean> holder) throws IllegalArgumentException { logger.info("bind(%s)", holder); bind(holder.get()); }
@Test public void testFindMetadataItemFromBadJPG() throws Exception { final DataObject dataObject = DataObject.find(FileUtil.createMemoryFileSystem().getRoot().createData("badfile")); final MetadataItemHolder<TIFF> holder = tiffProvider.findOrCreateItems(dataObject, EXTERNAL).iterator().next(); assertNotNull(holder); assertFalse(holder.isAvailable()); }
holder.addPropertyChangeListener(PROP_LATEST_MODIFICATION_TIME, propertyListener); holders.add(holder);
@Test public void testFindItemExternal() throws NoSuchMetadataTypeException { logger.info("******** testFindItemExternal()"); final MetadataItemHolder<MockItem1> holder1 = metadata.findOrCreateItem(MockItem1.class, EXTERNAL); assertNotNull(holder1); final MetadataItemHolder<MockItem1> holder2 = metadata.findOrCreateItem(MockItem1.class, EXTERNAL); assertNotNull(holder2); assertTrue(holder1 == holder2); final MockItem1 item1 = holder1.get(); final MockItem1 item2 = holder2.get(); assertTrue(item1 == item2); assertEquals(MetadataItemSourceMock1b.DATE, holder1.getLatestModificationTime()); // most recent }
/*************************************************************************** * * {@inheritDoc} * **************************************************************************/ @Override public <Item> int storeItem (@Nonnull final MetadataItemHolder<Item> holder, @Nonnull final StoreOption ... options) throws NoSuchMetadataTypeException { logger.info("storeItem(%s, %s)", holder, Arrays.toString(options)); if (holder == null) { throw new IllegalArgumentException("holder is mandatory"); } MetadataSpiUtils.validateOptions(options); final Class<Item> itemClass = (Class<Item>)holder.get().getClass(); final MetadataItemProvider<Item> metadataProvider = (MetadataItemProvider<Item>)providerMapByClass.get(itemClass); if (metadataProvider == null) { throw new NoSuchMetadataTypeException(itemClass); } return metadataProvider.storeItem(getDataObject(), holder, options); }
@Test public void testFindMetadataItemFromGoodFile() throws Exception { final DataObject dataObject = DataObject.find(FileUtil.createMemoryFileSystem().getRoot().createData("goodfile")); final MetadataItemHolder<TIFF> holder = tiffProvider.findOrCreateItems(dataObject, EXTERNAL).iterator().next(); assertNotNull(holder); assertTrue(holder.isAvailable()); }
@Test public void testFindMetadataItems() throws IOException { final DataObject dataObject = createDataObject("xxx"); final List<MetadataItemHolder<MockItem1>> holders = MetadataItemProviderSupport.findItems(MockItem1.class, dataObject, StorageType.ANY_TYPE); final Iterator<MetadataItemHolder<MockItem1>> i = holders.iterator(); final MetadataItemHolder<MockItem1> holder1 = i.next(); final MetadataItemHolder<MockItem1> holder2 = i.next(); assertNotNull(holder1); assertNotNull(holder2); final MockItem1 item1 = holder1.get(); final MockItem1 item2 = holder2.get(); assertNotNull(item1); assertNotNull(item2); assertTrue(item1 != item2); assertTrue(item1 instanceof MockItem1); assertTrue(item2 instanceof MockItem1); final Date timestamp1 = holder1.getLatestModificationTime(); assertNotNull(timestamp1); final Date timestamp2 = holder2.getLatestModificationTime(); assertNotNull(timestamp2); assertTrue(timestamp1.after(timestamp2)); } }
/*************************************************************************** * * **************************************************************************/ @Nonnull private MetadataItemHolder<Item> createNewItem() { final StopWatch stopWatch = StopWatch.create(MetadataItemProviderSupport.class, "createNewItem/" + itemClass.getName()); try { final MetadataItemHolder<Item> holder = createMetadataHolder(creationStrategy.createItem(itemClass)); if (holder.getLatestModificationTime() != null) { throw new AssertionError("MetadataHolders created by createMetadataHolder() must have getLatestModificationTime() == null"); } return holder; } catch (Exception e) { throw new RuntimeException(e); } finally { stopWatch.stop(); } } }
/*************************************************************************** * * Postprocesses a newly created metadata item. * * @param holder the item to postprocess * **************************************************************************/ private <T> void fireNotifyItemCreated (@Nonnull final MetadataItemHolder<T> holder) { logger.fine("fireNotifyItemCreated(%s)", holder); final Class<T> itemClass = (Class<T>)holder.get().getClass(); for (final MetadataItemInterceptor<?> interceptor : interceptors) { try { if (interceptor.getItemClass().isAssignableFrom(itemClass)) { ((MetadataItemInterceptor<T>)interceptor).notifyItemCreated(this, holder); } } catch (Throwable t) { logger.throwing(CLASS, "fireNotifyItemCreated()", t); logger.warning("fireNotifyItemCreated() threw exception: %s", interceptor); } } } }
@Before public void setupFixture() throws IOException, NoSuchMetadataTypeException { panelProvider = new MetadataPanelProviderMock(); FileUtil.setMIMEType("test", "image/test"); final FileSystem fileSystem = FileUtil.createMemoryFileSystem(); final FileObject root = fileSystem.getRoot(); dataObjectWithNoMetadata = DataObject.find(root.createData("nometadata.test")); assertTrue(dataObjectWithNoMetadata instanceof DataObjectMock); assertNull(dataObjectWithNoMetadata.getLookup().lookup(Metadata.class)); dataObjectWithItem = DataObject.find(root.createData("item.test")); assertTrue(dataObjectWithItem instanceof DataObjectMock); Metadata metadata = dataObjectWithItem.getLookup().lookup(Metadata.class); assertNotNull(metadata); MetadataItemHolder<MetadataItemMock> holder = metadata.findOrCreateItem(MetadataItemMock.class, INTERNAL); assertNotNull(holder); assertTrue(holder.isAvailable()); dataObjectWithNoItem = DataObject.find(root.createData("noitem.test")); assertTrue(dataObjectWithNoItem instanceof DataObjectMock); metadata = dataObjectWithNoItem.getLookup().lookup(Metadata.class); assertNotNull(metadata); holder = metadata.findOrCreateItem(MetadataItemMock.class, INTERNAL); assertNotNull(holder); assertFalse(holder.isAvailable()); }
final Date date = holder.getLatestModificationTime();
@Test public void testLastModificationTimeIsUpdated() throws InterruptedException, NoSuchMetadataTypeException { logger.info("******** testLastModificationTimeIsUpdated()"); assertEquals(MetadataItemSourceMock1b.DATE, metadata.getLatestModificationTime()); final MetadataItemHolder<MockItem1> item1 = metadata.findOrCreateItem(MockItem1.class, EXTERNAL); Thread.sleep(1000); Date now = new Date(); item1.get().setName("name1"); assertTrue(metadata.getLatestModificationTime().getTime() - now.getTime() < 50); Thread.sleep(1000); now = new Date(); item1.get().setName("name2"); assertTrue(metadata.getLatestModificationTime().getTime() - now.getTime() < 50); final MetadataItemHolder<MockItem2> item2 = metadata.findOrCreateItem(MockItem2.class, EXTERNAL); Thread.sleep(1000); now = new Date(); item2.get().setName("name2"); assertTrue(metadata.getLatestModificationTime().getTime() - now.getTime() < 50); }
@Test public void testFindItemsAny() throws NoSuchMetadataTypeException { logger.info("******** testFindItemsAny()"); final List<MetadataItemHolder<MockItem1>> items1 = metadata.findOrCreateItems(MockItem1.class, ANY_TYPE); assertNotNull(items1); assertEquals(items1.toString(), 3, items1.size()); final List<MetadataItemHolder<MockItem1>> items2 = metadata.findOrCreateItems(MockItem1.class, ANY_TYPE); assertEquals(items1.toString(), 3, items2.size()); assertNotNull(items2); assertTrue(String.format("%s vs %s", items1, items2), items1.equals(items2)); final MetadataItemHolder<MockItem1> item1 = items1.get(0); final MetadataItemHolder<MockItem1> item2 = items1.get(1); final MetadataItemHolder<MockItem1> item3 = items1.get(2); // We are using the different dates to distinguish the three items final List<Date> dates = new ArrayList<Date>(); dates.add(item1.getLatestModificationTime()); dates.add(item2.getLatestModificationTime()); dates.add(item3.getLatestModificationTime()); assertTrue(dates.contains(MetadataItemSourceMock1Internal.DATE)); assertTrue(dates.contains(MetadataItemSourceMock1a.DATE)); assertTrue(dates.contains(MetadataItemSourceMock1b.DATE)); }
@Test public void testFindItemsExternal() throws NoSuchMetadataTypeException { logger.info("******** testFindItemsExternal()"); final List<MetadataItemHolder<MockItem1>> holders1 = metadata.findOrCreateItems(MockItem1.class, EXTERNAL); assertNotNull(holders1); assertEquals(2, holders1.size()); final List<MetadataItemHolder<MockItem1>> holders2 = metadata.findOrCreateItems(MockItem1.class, EXTERNAL); assertEquals(2, holders2.size()); assertNotNull(holders2); assertTrue(holders1.equals(holders2)); final MetadataItemHolder<MockItem1> holder1 = holders1.get(0); final MetadataItemHolder<MockItem1> holder2 = holders1.get(1); assertEquals(MetadataItemSourceMock1b.DATE, holder1.getLatestModificationTime()); // most recent assertEquals(MetadataItemSourceMock1a.DATE, holder2.getLatestModificationTime()); }
@Test public void testFindItemsInternal() throws NoSuchMetadataTypeException { logger.info("******** testFindItemsInternal()"); final List<MetadataItemHolder<MockItem1>> holders1 = metadata.findOrCreateItems(MockItem1.class, INTERNAL); assertNotNull(holders1); assertEquals(1, holders1.size()); final List<MetadataItemHolder<MockItem1>> holders2 = metadata.findOrCreateItems(MockItem1.class, INTERNAL); assertEquals(1, holders2.size()); assertNotNull(holders2); assertTrue(holders1.equals(holders2)); final MetadataItemHolder<MockItem1> holder1 = holders1.get(0); assertEquals(MetadataItemSourceMock1Internal.DATE, holder1.getLatestModificationTime()); }