EDIT

cdmlib-remote/src/main/java/eu/etaxonomy/cdm/remote/editor/ClassPropertyEditor.java -text

* European Distributed Institute of Taxonomy 

* 

 * A {@link Media media} is any kind of media that represents a media object. 

 * This media object can have multiple {@link MediaRepresentation media representations} that differ in MIME-type 

 * and/or quality. 

 * E.g. 

 * (1) an image can have a tiff and a jpg media representation. 

 * (2) an formatted text can have a text/html or an application/pdf representation. 

	private static final long serialVersionUID = -1927421567263473658L;

	@SuppressWarnings("unused")

	private static final Logger logger = Logger.getLogger(Media.class);

	// private MultilanguageText title = new MultilanguageText();

	@XmlElement(name = "MediaTitle")

	private Map<Language,LanguageString> title = new HashMap<Language,LanguageString>();

	//creation date of the media (not of the record) 

	@XmlElement(name = "MediaCreated", type= String.class)

	@XmlJavaTypeAdapter(DateTimeAdapter.class)

	@Type(type="dateTimeUserType")

	@Basic(fetch = FetchType.LAZY)

	private DateTime mediaCreated;

	 // TODO once hibernate annotations support custom collection type

	// private MultilanguageText description = new MultilanguageText();

	@XmlElement(name = "MediaDescription")

	private Map<Language,LanguageString> description = new HashMap<Language,LanguageString>();

	//A single medium such as a picture can have multiple representations in files. 

	//Common are multiple resolutions or file formats for images for example

	@XmlElementWrapper(name = "MediaRepresentations")

	@XmlElement(name = "MediaRepresentation")

	@OneToMany(mappedBy="media",fetch = FetchType.LAZY)

	@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE, CascadeType.DELETE_ORPHAN, CascadeType.REFRESH})

	@NotNull

	@NotEmpty(groups = Level2.class)

	private Set<MediaRepresentation> representations = new HashSet<MediaRepresentation>();

	@XmlElement(name = "Artist")

	@XmlIDREF

	@XmlSchemaType(name = "IDREF")

	@ManyToOne(fetch = FetchType.LAZY)

	@IndexedEmbedded

	@Cascade(CascadeType.SAVE_UPDATE)

	private AgentBase artist;

	/**

	 * Factory method

	 * @return

	 */

	public static Media NewInstance(){

		return new Media();

	}

	/**

	 * Factory method which creates a new media, adds a reprsentation including mime type and suffix information

	 * and adds to the later a representation part for a given uri and size

	 * Returns <code>null</code> if uri is empty

	 * @return Media

	 */

	public static Media NewInstance(URI uri, Integer size, String mimeType, String suffix){

		MediaRepresentation representation = MediaRepresentation.NewInstance(mimeType, suffix, uri, size);

		if (representation == null){

			return null;

		}

		Media media = new Media();

		media.addRepresentation(representation);

		return media;

	}

	/**

	 * Constructor

	 */

	protected Media() {

		super();

		setMediaCacheStrategy();

	}

	private void setMediaCacheStrategy() {

		if (getClass() == Media.class){

			this.cacheStrategy = MediaDefaultCacheStrategy.NewInstance();

		}

	}

	public Set<MediaRepresentation> getRepresentations(){

		if(representations == null) {

			this.representations = new HashSet<MediaRepresentation>();

		}

		return this.representations;

	}

	@SuppressWarnings("deprecation")

	public void addRepresentation(MediaRepresentation representation){

		if (representation != null){

			this.getRepresentations().add(representation);

			representation.setMedia(this);

		}

	}

	@SuppressWarnings("deprecation")

	public void removeRepresentation(MediaRepresentation representation){

		this.getRepresentations().remove(representation);

		if (representation != null){

			representation.setMedia(null);

		}

	}

	public AgentBase getArtist(){

		return this.artist;

	}

	public void setArtist(AgentBase artist){

		this.artist = artist;

	}

	public LanguageString getTitle(){

		return getTitle(Language.DEFAULT());

	}

	public LanguageString getTitle(Language language){

		return title.get(language);

	}

	@Transient

	public Map<Language,LanguageString> getAllTitles(){

		if(title == null) {

			this.title = new HashMap<Language,LanguageString>();

		}

		return this.title;

	}

	/**

	 * Adds the languageString to the {@link MultilanguageText multilanguage text} 

	 * used to be the title of <i>this</i> media.

	 * 

	 * @param title		the languageString with the title in a particular language

	 * @see    	   		#getTitle()

	 * @see    	   		#putTitle(Language String)

	 * @deprecated		should follow the put semantic of maps, this method will be removed in v4.0

	 * 					Use the {@link #putTitle(LanguageString) putTitle} method instead

	 */

	@Deprecated

	public void addTitle(LanguageString title){

		this.putTitle(title);

	}

	public void putTitle(LanguageString title){

		this.title.put(title.getLanguage(), title);

	}

	/**

	 * Creates a {@link LanguageString language string} based on the given text string

	 * and the given {@link Language language} and adds it to the {@link MultilanguageText multilanguage text} 

	 * used to be the title of <i>this</i> media.

	 * 

	 * @param text		the title in a particular language

	 * @param language	the language in which the title string is formulated

	 * @see    	   		#getTitle()

	 * @see    	   		#putTitle(LanguageString)

	 * @deprecated		should follow the put semantic of maps, this method will be removed in v4.0

	 * 					Use the {@link #putTitle(Language, String) putTitle} method instead

	 */

	@Deprecated

	public void addTitle(String title, Language language){

		this.putTitle(language, title);

	}

	/**

	 * Creates a {@link LanguageString language string} based on the given text string

	 * and the given {@link Language language} and adds it to the {@link MultilanguageText multilanguage text} 

	 * used to be the title of <i>this</i> media.

	 * 

	 * @param language	the language in which the title string is formulated

	 * @param text		the title in a particular language

	 * 

	 * @see    	   		#getTitle()

	 * @see    	   		#putTitle(LanguageString)

	 */

	public void putTitle(Language language, String title){

		this.title.put(language, LanguageString.NewInstance(title, language));

	}

	public void removeTitle(Language language){

		this.title.remove(language);

	}

	@Transient 

	public String getTitleCacheByLanguage(Language lang){

		if (cacheStrategy != null){

			return ((MediaDefaultCacheStrategy)cacheStrategy).getTitleCacheByLanguage(this, lang);

		}else{

			return null;

		}

	}

	/*

	 * (non-Javadoc)

	 * @see eu.etaxonomy.cdm.model.common.IdentifiableEntity#setTitleCache(java.lang.String)

	 */

	@Override

	public void setTitleCache(String titleCache) {

		putTitle(LanguageString.NewInstance(titleCache, Language.DEFAULT()));

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getTitleCache()

	 */

	@Override

	public String getTitleCache(){

		if (protectedTitleCache){

			return this.titleCache;			

		}

		// is title dirty, i.e. equal NULL?

		if (titleCache == null){

			this.titleCache = generateTitle();

			this.titleCache = getTruncatedCache(this.titleCache) ;

		}else{

			//do the same as listeners on dependend objects like representations parts

			//are not yet installed

			this.titleCache = generateTitle();

			this.titleCache = getTruncatedCache(this.titleCache) ;

		}

		return titleCache;

	}

	public DateTime getMediaCreated(){

		return this.mediaCreated;

	}

	public void setMediaCreated(DateTime mediaCreated){

		this.mediaCreated = mediaCreated;

	}

	//************* Descriptions

	public Map<Language,LanguageString> getAllDescriptions(){

		if(this.description == null) {

			this.description = new HashMap<Language,LanguageString>();

		}

		return this.description;

	}

	public LanguageString getDescription(Language language){

		return getAllDescriptions().get(language);

	}

	public void addDescription(LanguageString description){

		this.description.put(description.getLanguage(), description);

	}

	public void addDescription(String text, Language language){

		this.description.put(language, LanguageString.NewInstance(text, language));

	}

	public void removeDescription(Language language){

		this.description.remove(language);

	}

	/* (non-Javadoc)

	 * @see java.lang.Object#clone()

	 */

	@Override

	public Object clone() throws CloneNotSupportedException{

		Media result = (Media)super.clone();

		//description

		result.description = new HashMap<Language, LanguageString>();

		for (Language language: this.description.keySet()){

			result.description.put(language, this.description.get(language));

		}

		//title

		result.title = new HashMap<Language, LanguageString>();

		for (Language language: this.title.keySet()){

			result.title.put(language, this.title.get(language));

		}

		//media representations

		result.representations = new HashSet<MediaRepresentation>();

		for (MediaRepresentation mediaRepresentation: this.representations){

			result.representations.add((MediaRepresentation)mediaRepresentation.clone());

		}

		//no changes to: artist

		return result;

	}

	public int compareTo(Object o) {

		return 0;

	}

	private static final Logger logger = Logger.getLogger(MediaUtils.class);

	/**

	 * @param mimeTypeRegexes

	 * @param size

	 * @param widthOrDuration

	 * @param height

	 * @return

	 * 

	 * 

	 */

	public static MediaRepresentation findBestMatchingRepresentation(Media media, Integer size, Integer height, Integer widthOrDuration, String[] mimeTypes){

		// find best matching representations of each media

		SortedMap<Integer, MediaRepresentation> prefRepresentations 

			= orderMediaRepresentations(media, mimeTypes, size, widthOrDuration, height);

			try {

				// take first one and remove all other representations

				MediaRepresentation prefOne = prefRepresentations.get(prefRepresentations.firstKey());

				return prefOne;

			} catch (NoSuchElementException nse) {

				/* IGNORE */

			}

			return null;

		}

	/**

	 * @param mediaList

	 * @param mimeTypes

	 * @param sizeTokens

	 * @param widthOrDuration

	 * @param height

	 * @param size

	 * @return

	 */

	public static List<Media> findPreferredMedia(List<Media> mediaList,

			String[] mimeTypes, String[] sizeTokens, Integer widthOrDuration,

			Integer height, Integer size) {

		for(int i=0; i<mimeTypes.length; i++){

			mimeTypes[i] = mimeTypes[i].replace(':', '/');

		}

		if(sizeTokens.length > 0){

			try {

				size = Integer.valueOf(sizeTokens[0]);

			} catch (NumberFormatException nfe) {

				/* IGNORE */

			}

		}

		if(sizeTokens.length > 1){

			try {

				widthOrDuration = Integer.valueOf(sizeTokens[1]);

			} catch (NumberFormatException nfe) {

				/* IGNORE */

			}

		}

		if(sizeTokens.length > 2){

			try {

				height = Integer.valueOf(sizeTokens[2]);

			} catch (NumberFormatException nfe) {

				/* IGNORE */

			}

		}

		List<Media> returnMedia = new ArrayList<Media>(mediaList.size());

		if(mediaList != null){

			for(Media media : mediaList){

				SortedMap<Integer, MediaRepresentation> prefRepresentations 

					= orderMediaRepresentations(media, mimeTypes, size, widthOrDuration, height);

				try {

					// take first one and remove all other representations

					MediaRepresentation prefOne = prefRepresentations.get(prefRepresentations.firstKey());

					for (MediaRepresentation representation : media.getRepresentations()) {

						if (representation != prefOne) {

							media.removeRepresentation(representation);

						}

					}

					returnMedia.add(media);

				} catch (NoSuchElementException nse) {

					logger.debug(nse);

					/* IGNORE */

				}

			}

		}

		return returnMedia;

	}

	/**

	 * @param media

	 * @param mimeTypeRegexes

	 * @param size

	 * @param widthOrDuration

	 * @param height

	 * @return

	 * 

	 * TODO move into a media utils class

	 * TODO implement the quality filter  

	public static SortedMap<String, MediaRepresentation> orderMediaRepresentations(Media media, String[] mimeTypeRegexes,

			Integer size, Integer widthOrDuration, Integer height) {

		SortedMap<String, MediaRepresentation> prefRepr = new TreeMap<String, MediaRepresentation>();

		for (String mimeTypeRegex : mimeTypeRegexes) {

			// getRepresentationByMimeType

			Pattern mimeTypePattern = Pattern.compile(mimeTypeRegex);

			int representationCnt = 0;

			for (MediaRepresentation representation : media.getRepresentations()) {

				int dwa = 0;

				if(representation.getMimeType() == null){

					prefRepr.put((dwa + representationCnt++) + "_NA", representation);

				} else {

					Matcher mather = mimeTypePattern.matcher(representation.getMimeType());

					if (mather.matches()) {

						/* TODO the quality filter part is being skipped 

						 * // look for representation with the best matching parts

						for (MediaRepresentationPart part : representation.getParts()) {

							if (part instanceof ImageFile) {

								ImageFile image = (ImageFile) part;

								int dw = image.getWidth() * image.getHeight() - height * widthOrDuration;

								if (dw < 0) {

									dw *= -1;

								}

								dwa += dw;

							}

							dwa = (representation.getParts().size() > 0 ? dwa / representation.getParts().size() : 0);

						}

						prefRepr.put((dwa + representationCnt++) + '_' + representation.getMimeType(), representation);

						// preferred mime type found => end loop

						break;

					}

				}

			}

		}

		return prefRepr;

	}

	*/

	/**

	 * @param mimeTypeRegexes

	 * @param size

	 * @param widthOrDuration

	 * @param height

	 * @return

	 * 

	 * 

	 */

	private static SortedMap<Integer, MediaRepresentation> orderMediaRepresentations(Media media, String[] mimeTypeRegexes,

			Integer size, Integer widthOrDuration, Integer height) {

		SortedMap<Integer, MediaRepresentation> prefRepr = new TreeMap<Integer, MediaRepresentation>();

//		SortedMap<String, MediaRepresentation> sortedForSizeDistance = new TreeMap<String, MediaRepresentation>();		

//		String keyString = "";

		size = (size == null ? new Integer(0) : size );

		widthOrDuration = (widthOrDuration == null ? new Integer(0) : widthOrDuration);

		height = (height == null ? new Integer(0) : height);

		mimeTypeRegexes = (mimeTypeRegexes == null ? new String[]{} : mimeTypeRegexes);

		if(media != null){

			for (String mimeTypeRegex : mimeTypeRegexes) {

				// getRepresentationByMimeType

				Pattern mimeTypePattern = Pattern.compile(mimeTypeRegex);

				int representationCnt = 0;

				for (MediaRepresentation representation : media.getRepresentations()) {

					if(representation.getMimeType() != null){

						Matcher mather = mimeTypePattern.matcher(representation.getMimeType());

						if (mather.matches()) {

							int dwa = 0;

							//first the size is used for comparison

							for (MediaRepresentationPart part : representation.getParts()) {

								if (part.getSize()!= null){

									int sizeOfPart = part.getSize();

									int distance = sizeOfPart - size;

									if (distance < 0) {

										distance*= -1;

									}

									dwa += distance;

								}

								//if height and width/duration is defined, add this information, too

								if (height != 0 && widthOrDuration != 0){

									int dw = 0;

									if (part instanceof ImageFile) {

										ImageFile image = (ImageFile) part;

										dw = image.getWidth() * image.getHeight() - height * widthOrDuration;

									}

									else if (part instanceof MovieFile){

										MovieFile movie = (MovieFile) part;

										dw = movie.getDuration() - widthOrDuration;

									}else if (part instanceof AudioFile){

										AudioFile audio = (AudioFile) part;

										dw = audio.getDuration() - widthOrDuration;

									}

									if (dw < 0) {

										dw *= -1;

									}

									dwa += dw;

								}

							}

							dwa = (representation.getParts().size() > 0 ? dwa / representation.getParts().size() : 0);

							//keyString =(dwa + representationCnt++) + '_' + representation.getMimeType();

							prefRepr.put((dwa + representationCnt++), representation);

						}

					}		

				}										

			}

		}

		return prefRepr;

	}

* European Distributed Institute of Taxonomy 

* 

	@SuppressWarnings("unused")

	private static final Logger logger = Logger.getLogger(MediaTest.class);

	private Media media1; 

	private Team team1;

	private MediaRepresentation mediaRepresentation1;

	private MediaRepresentation mediaRepresentation2;

	private MediaRepresentationPart mediaRepresentationPart1;

	private MediaRepresentationPart mediaRepresentationPart2;

	private LanguageString languageString1;

	private final String germanDescription = "media1Desc2";

	private Rights rights1;

	private LanguageString languageString2;

	private static URI uriString1;

	private static URI uriString2;

	/**

	 * @throws java.lang.Exception

	 */

	@BeforeClass

	public static void setUpBeforeClass() throws Exception {

		DefaultTermInitializer termInitializer = new DefaultTermInitializer();

		termInitializer.initialize();

		try {

			uriString1 = new URI("http://Pathtoimage1/");

			uriString2 = new URI("http://Path_to_image_2/");

		} catch (Exception e) {

			e.printStackTrace();

			Assert.fail("Error in URI syntax");

		}

	}

	/**

	 * @throws java.lang.Exception

	 */

	@AfterClass

	public static void tearDownAfterClass() throws Exception {

	}

	/**

	 * @throws java.lang.Exception

	 */

	@Before

	public void setUp() throws Exception {

		media1 = Media.NewInstance();

		team1 = Team.NewInstance();

		media1.setArtist(team1);

		media1.setMediaCreated(new DateTime(2002, 1,1,0,0,0,0));

		languageString1 = LanguageString.NewInstance("media1Desc", Language.DEFAULT());

		media1.addDescription(languageString1);

		media1.addDescription("media1Desc2", Language.GERMAN());

		mediaRepresentation1 = MediaRepresentation.NewInstance();

		mediaRepresentation2 = MediaRepresentation.NewInstance();

		mediaRepresentation1.setMimeType("MimeType1");

		mediaRepresentation2.setMimeType("MimeType1");

		mediaRepresentationPart1 = ImageFile.NewInstance(uriString1, 100);

		mediaRepresentationPart2 = ImageFile.NewInstance(uriString2, 1000);

		((ImageFile) mediaRepresentationPart1).setHeight(100);

		((ImageFile) mediaRepresentationPart1).setWidth(100);

		((ImageFile) mediaRepresentationPart2).setHeight(100);

		((ImageFile) mediaRepresentationPart2).setWidth(100);

		mediaRepresentation1.addRepresentationPart(mediaRepresentationPart1);

		mediaRepresentation2.addRepresentationPart(mediaRepresentationPart2);

		media1.addRepresentation(mediaRepresentation1);

		media1.addRepresentation(mediaRepresentation2);

		rights1 = Rights.NewInstance();

		media1.addRights(rights1);

		languageString2 = LanguageString.NewInstance("media1Title", Language.DEFAULT());

		media1.putTitle(languageString2);

	}

	/**

	 * @throws java.lang.Exception

	 */

	@After

	public void tearDown() throws Exception {

	}

//***************** TESTS *********************************/	

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#clone()}.

	 */

	@Test

	public void testClone() {

		try {

			Media mediaClone = (Media)media1.clone();

			Assert.assertSame("Artist must be the same", team1, mediaClone.getArtist());

			Assert.assertTrue("Clone must have a default language description", mediaClone.getAllDescriptions().containsKey(Language.DEFAULT()));

			Assert.assertSame("Description1 must be the same", languageString1, mediaClone.getAllDescriptions().get(Language.DEFAULT()) );

			Assert.assertTrue("Clone must have a german description", mediaClone.getAllDescriptions().containsKey(Language.GERMAN()));

			Assert.assertEquals("German description must equal media1Desc2", germanDescription, mediaClone.getAllDescriptions().get(Language.GERMAN()).getText() );

			Assert.assertEquals("Media created year must be 2002", 2002, mediaClone.getMediaCreated().getYear());

			Assert.assertEquals("Number of media representations must be 2", 2, mediaClone.getRepresentations().size());

			Assert.assertNotSame("Only media representation must not be mediaRepresentation1", mediaRepresentation1, mediaClone.getRepresentations().iterator().next());

			Assert.assertEquals("Only meda representation must have same MimeType as mediaRepresentation1", mediaRepresentation1.getMimeType(), mediaClone.getRepresentations().iterator().next().getMimeType());

			Assert.assertTrue("Rights must contain rights1", mediaClone.getRights().contains(rights1));

			Assert.assertTrue("Clone must have a default language title", mediaClone.getAllTitles().containsKey(Language.DEFAULT()));

			Assert.assertSame("Title must be the same", languageString2, mediaClone.getAllTitles().get(Language.DEFAULT()) );

		} catch (CloneNotSupportedException e) {

			Assert.fail("Media must be cloneable");

		}

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#addRepresentation(eu.etaxonomy.cdm.model.media.MediaRepresentation)}.

	 */

	@Test

	public void testAddRepresentation() {

		Assert.assertTrue("Representations must contain mediaRepresentation1", media1.getRepresentations().contains(mediaRepresentation1));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#removeRepresentation(eu.etaxonomy.cdm.model.media.MediaRepresentation)}.

	 */

	@Test

	public void testRemoveRepresentation() {

		Assert.assertTrue("Representations must contain mediaRepresentation1", media1.getRepresentations().contains(mediaRepresentation1));

		media1.removeRepresentation(mediaRepresentation1);

		Assert.assertFalse("Representations must not contain mediaRepresentation1", media1.getRepresentations().contains(mediaRepresentation1));

		Assert.assertEquals("Number of representations must be 1", 1, media1.getRepresentations().size());

		media1.removeRepresentation(mediaRepresentation2);

		Assert.assertFalse("Representations must not contain mediaRepresentation2", media1.getRepresentations().contains(mediaRepresentation2));

		Assert.assertEquals("Number of representations must be 0", 0, media1.getRepresentations().size());

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#addRights(eu.etaxonomy.cdm.model.media.Rights)}.

	 */

	@Test

	public void testAddRights() {

		Assert.assertTrue("Rights must contain rights1", media1.getRights().contains(rights1));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#removeRights(eu.etaxonomy.cdm.model.media.Rights)}.

	 */

	@Test

	public void testRemoveRights() {

		Assert.assertTrue("Rights must contain rights1", media1.getRights().contains(rights1));

		media1.removeRights(rights1);

		Assert.assertFalse("Rights must not contain rights1", media1.getRights().contains(rights1));

		Assert.assertEquals("Number of rights must be 0", 0, media1.getRights().size());	

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#addTitle(eu.etaxonomy.cdm.model.common.LanguageString)}.

	 */

	@Test

	public void testAddTitle() {

		Assert.assertSame("Title must be the same", languageString2, media1.getAllTitles().get(Language.DEFAULT()) );

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#removeTitle(eu.etaxonomy.cdm.model.common.Language)}.

	 */

	@Test

	public void testRemoveTitle() {

		Assert.assertSame("Title must be the same", languageString2, media1.getAllTitles().get(Language.DEFAULT()) );

		media1.removeTitle(Language.GERMAN());

		Assert.assertEquals("Number of titles must be 1", 1, media1.getAllTitles().size());

		media1.removeTitle(Language.DEFAULT());

		Assert.assertEquals("Number of titles must be 0", 0, media1.getAllTitles().size());

		Assert.assertFalse("Title must not contain languageString2", languageString2.equals(media1.getAllTitles().get(Language.DEFAULT())));

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#getMediaCreated()}.

	 */

	@Test

	public void testGetMediaCreated() {

		Assert.assertEquals("Media created year must be 2002", 2002, media1.getMediaCreated().getYear());

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#getDescription()}.

	 */

	@Test

	public void testGetDescription() {

		Assert.assertTrue("Clone must have a default language description", media1.getAllDescriptions().containsKey(Language.DEFAULT()));

		Assert.assertSame("Description1 must be the same", languageString1, media1.getAllDescriptions().get(Language.DEFAULT()) );

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#addDescription(eu.etaxonomy.cdm.model.common.LanguageString)}.

	 */

	@Test

	public void testAddDescriptionLanguageString() {

		Assert.assertEquals("Number of descriptions must be 2", 2, media1.getAllDescriptions().size() );

		Assert.assertTrue("Clone must have a default language description", media1.getAllDescriptions().containsKey(Language.DEFAULT()));

		Assert.assertSame("Description1 must be the same", languageString1, media1.getAllDescriptions().get(Language.DEFAULT()) );

		media1.addDescription(languageString2);

		Assert.assertEquals("Number of descriptions must be 2", 2, media1.getAllDescriptions().size() );

		Assert.assertEquals("Default language description must be languageString2", languageString2, media1.getAllDescriptions().get(Language.DEFAULT()) );

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#addDescription(java.lang.String, eu.etaxonomy.cdm.model.common.Language)}.

	 */

	@Test

	public void testAddDescriptionStringLanguage() {

		Assert.assertTrue("Clone must have a german language description", media1.getAllDescriptions().containsKey(Language.GERMAN()));

		Assert.assertSame("Description1 must be the same", "media1Desc2", media1.getAllDescriptions().get(Language.GERMAN()).getText() );

		media1.addDescription("testDesc", Language.DEFAULT());

		Assert.assertEquals("Number of descriptions must be 2", 2, media1.getAllDescriptions().size() );

		media1.addDescription("testDesc2", Language.DEFAULT());

		Assert.assertEquals("Number of descriptions must be 2", 2, media1.getAllDescriptions().size() );

		Assert.assertSame("Default language description must be 'testDesc2'", "testDesc2", media1.getAllDescriptions().get(Language.DEFAULT()).getText() );

	}

	/**

	 * Test method for {@link eu.etaxonomy.cdm.model.media.Media#removeDescription(eu.etaxonomy.cdm.model.common.Language)}.

	 */

	@Test

	public void testRemoveDescription() {

		Assert.assertEquals("Number of descriptions must be 2", 2, media1.getAllDescriptions().size() );

		Assert.assertTrue("Clone must have a default language description", media1.getAllDescriptions().containsKey(Language.DEFAULT()));

		Assert.assertSame("Description1 must be the same", languageString1, media1.getAllDescriptions().get(Language.DEFAULT()) );

		media1.removeDescription(Language.JAPANESE());

		Assert.assertEquals("Number of descriptions must be 2", 2, media1.getAllDescriptions().size() );

		media1.removeDescription(Language.DEFAULT());

		Assert.assertEquals("Number of descriptions must be 1", 1, media1.getAllDescriptions().size() );

		media1.removeDescription(Language.DEFAULT());

		Assert.assertEquals("Number of descriptions must be 1", 1, media1.getAllDescriptions().size() );

		media1.removeDescription(Language.GERMAN());

		Assert.assertEquals("Number of descriptions must be 0", 0, media1.getAllDescriptions().size() );

	}

	@Test

	public void testfindBestMatchingRepresentation() {

		String[] mimetypes = {".*"};

		Assert.assertEquals(mediaRepresentation1, MediaUtils.findBestMatchingRepresentation(media1, 100, 100, 100, mimetypes));

		Assert.assertEquals(mediaRepresentation2, MediaUtils.findBestMatchingRepresentation(media1,1000, 100, 100, mimetypes));

	}