@Override public String toString() { if (toStringCache == null) { toStringCache = type.getName() + "/" + subType.getFacet().getRegistrationTreeName().map(tree -> tree + ".").orElse("") + subType.getName() + subType.getSuffix().map(suffix -> "+" + suffix).orElse("") + parameters.entrySet().stream().map(entry -> ";" + entry.getKey() + "=" + entry.getValue()) .collect(Collectors.joining()); } return toStringCache; } }
/** * Creates a SubType with a Name assigned to the given name, an empty suffix, and assigned to the STANDARD * facet. * * @param name * the name of this subtype * * @return a SubType with a Name assigned to the given name, an empty suffix, and assigned to the STANDARD * facet. */ public static SubType of(final String name) { return new SubType(Facet.STANDARD, name, Optional.empty()); }
@Test public void test_mimetype_to_string_works () { final Map<String,String> parameters = new HashMap<>(); parameters.put("key","value"); final MimeType complex = MimeType.of( MimeType.Type.EXAMPLE, MimeType.SubType.of(MimeType.Facet.PERSONAL, "niketest", Optional.of("json")), parameters ); assertThat(complex.toString()).isEqualTo("example/prs.niketest+json;key=value"); }
Optional<String> givenSuffix = (suffixString == null || suffixString.isEmpty()) ? Optional.empty() : Optional.of(suffixString); SubType givenSubType = SubType.of(givenFacet, subTypeName, givenSuffix); MimeType givenMimeType = MimeType.of(givenType, givenSubType, Collections.emptyMap());
if (thisSubType.getSuffix().isPresent() && !(thatSubType.getSuffix().isPresent())) return -1; if (!(thisSubType.getSuffix().isPresent()) && thatSubType.getSuffix().isPresent()) return 1; return typeCompare; final int subTypeCompare = thisSubType.getName().compareTo(thatSubType.getName()); if (subTypeCompare != 0) return subTypeCompare;
@Test public void test_mimetype_parser_does_parse_valid_mimetype_in_the_vendor_facet_with_a_json_suffix_and_one_parameter () throws ParserFailure { Optional<MimeType> oResult; MimeType mime; oResult = MimeTypeParser.parse("application/vnd.nike.runningcoach-v3.1+json;charset=UTF-8"); assertThat(oResult.isPresent()).isTrue(); assertThat(oResult.get()).isNotNull(); mime = oResult.get(); assertThat(mime.getType()).isEqualTo(MimeType.Type.APPLICATION); assertThat(mime.getSubType().getName()).isEqualTo("nike.runningcoach-v3.1"); assertThat(mime.getSubType().getFacet()).isEqualTo(MimeType.Facet.VENDOR); assertThat(mime.getSubType().getSuffix()).isNotNull(); assertThat(mime.getSubType().getSuffix().get()).isNotNull(); assertThat(mime.getSubType().getSuffix().get()).isEqualTo("json"); assertThat(mime.getParameters()).isNotNull(); assertThat(mime.getParameters()).isNotEmpty(); assertThat(mime.getParameters().get("charset")).isNotNull(); assertThat(mime.getParameters().get("charset")).isEqualTo("UTF-8"); }
@Test public void test_mimetype_parser_does_parse_valid_mimetype_in_the_vendor_facet_with_a_json_suffix () throws ParserFailure { Optional<MimeType> oResult; MimeType mime; oResult = MimeTypeParser.parse("application/vnd.nike.runningcoach-v3.1+json"); assertThat(oResult.isPresent()).isTrue(); assertThat(oResult.get()).isNotNull(); mime = oResult.get(); assertThat(mime.getType()).isEqualTo(MimeType.Type.APPLICATION); assertThat(mime.getSubType().getName()).isEqualTo("nike.runningcoach-v3.1"); assertThat(mime.getSubType().getFacet()).isEqualTo(MimeType.Facet.VENDOR); assertThat(mime.getSubType().getSuffix()).isNotNull(); assertThat(mime.getSubType().getSuffix().get()).isNotNull(); assertThat(mime.getSubType().getSuffix().get()).isEqualTo("json"); assertThat(mime.getParameters()).isNotNull(); assertThat(mime.getParameters()).isEmpty(); }
@Test public void test_mimetype_parser_does_parse_valid_mimetype_in_the_standard_facet_without_a_suffix_and_two_parameters () throws ParserFailure { Optional<MimeType> oResult; MimeType mime; oResult = MimeTypeParser.parse("application/json; param1=one; param2=two"); assertThat(oResult.isPresent()).isTrue(); assertThat(oResult.get()).isNotNull(); mime = oResult.get(); assertThat(mime.getType()).isEqualTo(MimeType.Type.APPLICATION); assertThat(mime.getSubType().getName()).isEqualTo("json"); assertThat(mime.getParameters()).isNotNull(); assertThat(mime.getParameters()).isNotEmpty(); assertThat(mime.getParameters().size()).isEqualTo(2); assertThat(mime.getParameters().get("param1")).isNotNull(); assertThat(mime.getParameters().get("param1")).isEqualTo("one"); assertThat(mime.getParameters().get("param2")).isNotNull(); assertThat(mime.getParameters().get("param2")).isEqualTo("two"); }
@Test public void toString_sets_and_uses_cache() { // given MimeMediaRangeSubType instance = new MimeMediaRangeSubType(MimeType.SubType.of("foo")); assertThat(getToStringCache(instance)).isNull(); // when String toStringVal = instance.toString(); // then assertThat(getToStringCache(instance)).isEqualTo(toStringVal); // and when String newCustomVal = UUID.randomUUID().toString(); Whitebox.setInternalState(instance, "toStringCache", newCustomVal); // then assertThat(instance.toString()).isEqualTo(newCustomVal); } }
/** * Creates a SubType assigned with the given name, suffix, and facet. * Note, per RFC-6838 4.2, top-level type and subtype names are case-insensitive. * * @param facet * the facet to assign the subtype * @param name * the name to assign the subtype * @param suffix * the suffix to assign the subtype * * @return a SubType assigned with the given name, suffix, and facet */ public static SubType of(final Facet facet, final String name, final Optional<String> suffix) { return new SubType(facet, name, suffix); }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final MimeType mimeType = (MimeType) o; if (!getType().equals(mimeType.getType())) return false; //noinspection SimplifiableIfStatement if (!getSubType().equals(mimeType.getSubType())) return false; return getParameters().equals(mimeType.getParameters()); }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final SubType subType = (SubType) o; if (getFacet() != subType.getFacet()) return false; //noinspection SimplifiableIfStatement if (!getName().equals(subType.getName())) return false; return getSuffix().equals(subType.getSuffix()); }
@Test public void test_mimetype_compares_two_indentical_instances_correctly () { final MimeType one = MimeType.of(MimeType.Type.APPLICATION, MimeType.SubType.of("json")); final MimeType two = MimeType.of(MimeType.Type.APPLICATION, MimeType.SubType.of("json")); assertThat(one).isEqualTo(two); assertThat(one.hashCode()).isEqualTo(two.hashCode()); }
@Override public int hashCode() { return subType.hashCode(); }
@Test public void test_mimetype_parser_does_parse_valid_mimetype_in_the_standard_facet_without_a_suffix () throws ParserFailure { Optional<MimeType> oResult; MimeType mime; oResult = MimeTypeParser.parse("application/json"); assertThat(oResult.isPresent()).isTrue(); assertThat(oResult.get()).isNotNull(); mime = oResult.get(); assertThat(mime.getType()).isEqualTo(MimeType.Type.APPLICATION); assertThat(mime.getSubType().getName()).isEqualTo("json"); }
private MediaRangeSubType mrSubType(String typeString) { if (MediaRange.WILDCARD_SUBTYPE.toString().equals(typeString)) return MediaRange.WILDCARD_SUBTYPE; MimeType.Facet facet = MimeType.Facet.STANDARD; if (typeString.startsWith(MimeType.Facet.VENDOR.getRegistrationTreeName().get())) facet = MimeType.Facet.VENDOR; Optional<String> suffix = Optional.empty(); if (typeString.endsWith("+json")) suffix = Optional.of("json"); return new MimeMediaRangeSubType(MimeType.SubType.of(facet, typeString, suffix)); }
@Test public void equals_returns_true_for_same_instance() { // given MimeMediaRangeSubType instance = new MimeMediaRangeSubType(MimeType.SubType.of("foo")); // expect assertThat(instance.equals(instance)).isTrue(); }
@Test public void test_mimetype_compares_two_different_instances_correctly () { final MimeType one = MimeType.of(MimeType.Type.APPLICATION, MimeType.SubType.of("json")); final MimeType two = MimeType.of(MimeType.Type.APPLICATION, MimeType.SubType.of(MimeType.Facet.STANDARD, "schema", Optional.of("json"))); assertThat(one).isNotEqualTo(two); assertThat(one.hashCode()).isNotEqualTo(two.hashCode()); }