@Test
public void findAllTest2() throws Exception {
    Auction auction = new Auction();
    auction.setRealmId(1);
    auction.setItemId(124105);
    List<Auction> auctions = auctionService.findAll(auction);
    ObjectMapper mapper = new ObjectMapper();
    FilterProvider filters = new SimpleFilterProvider().addFilter("auctionFilter",SimpleBeanPropertyFilter.filterOutAllExcept("owner"));

    MappingJacksonValue mappingJacksonValue = new MappingJacksonValue(auctions);
    mappingJacksonValue.setFilters(filters);
    System.out.println(mappingJacksonValue.getValue());
}

private ObjectMapper createMapper(JsonFactory mapping,ClassLoader classLoader) {
    ObjectMapper mapper = new ObjectMapper(mapping);
    mapper.addMixIn(MasterSlaveServersConfig.class,MasterSlaveServersConfigMixIn.class);
    mapper.addMixIn(SingleServerConfig.class,SingleSeverConfigMixIn.class);
    mapper.addMixIn(Config.class,ConfigMixIn.class);
    mapper.addMixIn(CodecProvider.class,ClassMixIn.class);
    mapper.addMixIn(ResolverProvider.class,ClassMixIn.class);
    mapper.addMixIn(Codec.class,ClassMixIn.class);
    mapper.addMixIn(RedissonNodeInitializer.class,ClassMixIn.class);
    mapper.addMixIn(LoadBalancer.class,ClassMixIn.class);
    FilterProvider filterProvider = new SimpleFilterProvider()
            .addFilter("classFilter",SimpleBeanPropertyFilter.filterOutAllExcept());
    mapper.setFilterProvider(filterProvider);
    mapper.setSerializationInclusion(Include.NON_NULL);

    if (classLoader != null) {
        TypeFactory tf = TypeFactory.defaultInstance()
                .withClassLoader(classLoader);
        mapper.setTypeFactory(tf);
    }

    return mapper;
}

@Test
public void renderSimpleBeanWithFilters() throws Exception {
    TestSimpleBeanFiltered bean = new TestSimpleBeanFiltered();
    bean.setProperty1("value");
    bean.setProperty2("value");
    Map<String,Object> model = new HashMap<String,Object>();
    model.put("bindingResult",mock(BindingResult.class,"binding_result"));
    model.put("foo",bean);
    FilterProvider filters = new SimpleFilterProvider().addFilter("myJacksonFilter",SimpleBeanPropertyFilter.serializeAllExcept("property2"));
    model.put(FilterProvider.class.getName(),filters);

    view.setUpdateContentLength(true);
    view.render(model,request,response);

    String content = response.getContentAsstring();
    assertTrue(content.length() > 0);
    assertEquals(content.length(),response.getContentLength());
    assertthat(content,containsstring("\"property1\":\"value\""));
    assertthat(content,not(containsstring("\"property2\":\"value\"")));
    assertFalse(content.contains(FilterProvider.class.getName()));
}

@Test
public void test() throws Exception {
  SomeObject someObject = new SomeObject(1,2,3);
  PropertyFilter withoutB = SimpleBeanPropertyFilter.serializeAllExcept("b");

  String actual = mapper.writeValueAsstring(someObject);
  Assert.assertEquals(1,parser.parse(actual).read("$.a",Integer.class).intValue());
  Assert.assertEquals(2,parser.parse(actual).read("$.b",Integer.class).intValue());
  Assert.assertEquals(3,parser.parse(actual).read("$.c",Integer.class).intValue());

  actual = mapper.writer(new DynamicFilterProvider(withoutB)).writeValueAsstring(someObject);
  Assert.assertEquals(1,Integer.class).intValue());
  Assert.assertNull(parser.parse(actual).read("$.b"));
  Assert.assertEquals(3,Integer.class).intValue());

  actual = mapper.writeValueAsstring(someObject);
  Assert.assertEquals(1,Integer.class).intValue());

  actual = mapper.writer(new DynamicFilterProvider()).writeValueAsstring(someObject);
  Assert.assertEquals(1,Integer.class).intValue());
}

@Test
public void testReadRdf() throws IOException,JsonLdError {
    // FIXME this does not really test the output
    Phenopacket packet = YamlReader
            .readFile("src/test/resources/context/phenopacket-with-context.yaml");
    Model model = RdfGenerator.toRdf(packet,null);
    String packetID = packet.getId();
    Phenopacket newPacket = RdfReader.readModel(model,ContextUtil.expandIdentifierAsValue(packetID,packet));
    ObjectMapper m = new ObjectMapper();
    m.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    m.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenopacketClass",SimpleBeanPropertyFilter.serializeAll()));
    ObjectWriter writer = m.writerWithDefaultPrettyPrinter();
    System.out.println(writer.writeValueAsstring(newPacket));
}

@Test
public void ensureThatSerializingASymbolWithoutProjectDoesNotCrash() throws JsonProcessingException {
    String expectedJson = "{\"actions\":["
                + "{\"type\":\"web_click\",\"disabled\":false,\"negated\":false,\"ignoreFailure\":false,"
                        + "\"errorOutput\":null,\"node\":null,\"doubleClick\":false},"
                + "{\"type\":\"web_checkForText\","
                    + "\"errorOutput\":null,\"value\":\"F[oO0]+\",\"regexp\":true},"
                + "{\"type\":\"wait\",\"duration\":" + ONE_SECOND + "}"
            + "],\"group\":2,\"id\":null,\"name\":\"WebSymbol\",\"project\":null,\"successOutput\":null}";
    symbol.setProject(null);

    ObjectMapper mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Object.class,PropertyFilterMixIn.class);

    SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.serializeAllExcept("hidden");
    FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name",filter);

    String json = mapper.writer(filters).writeValueAsstring(symbol);

    assertEquals(expectedJson,json);
}

/**
 * Create a new JsonManager
 * @param theClass The class to create a json manager for (yes,also in the diamonds).
 */
public JsonManager (Class<T> theClass) {
    this.theClass = theClass;
    this.mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Rectangle2D.class,Rectangle2DMixIn.class);
    mapper.registerModule(new GeoJsonModule());
    SimpleModule deser = new SimpleModule();

    deser.addDeserializer(LocalDate.class,new JacksonSerializers.LocalDateStringDeserializer());
    deser.addSerializer(LocalDate.class,new JacksonSerializers.LocalDateStringSerializer());

    deser.addDeserializer(Rectangle2D.class,new Rectangle2DDeserializer());
    mapper.registerModule(deser);
    mapper.getSerializerProvider().setNullKeySerializer(new JacksonSerializers.MyDtoNullKeySerializer());
    filters = new SimpleFilterProvider();
    filters.addFilter("bBox",SimpleBeanPropertyFilter.filterOutAllExcept("west","east","south","north"));
    this.writer = mapper.writer(filters);
}

@Test
public void createtest() throws Exception {

    EntrezGene
            gene = new EntrezGene(6L,"GeneF",9606,"","10","protein-coding",null,null);
    objectMapper.setFilterProvider(new SimpleFilterProvider().addFilter("fieldFilter",SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnkNownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    mockmvc.perform(post(BASE_URL)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$",hasKey("entrezGeneId")))
            .andExpect(jsonPath("$.entrezGeneId",is(6)));

    mockmvc.perform(get(BASE_URL + "/{id}",6L))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.entrezGeneId",is(6)));

    geneRepository.delete(6L);

}

private ObjectWriter getobjectWriter(ObjectMapper mapper,String[] fieldsToReturn) {

        if (fieldsToReturn.length != 0) {
            mapper.addMixInAnnotations(
                    Object.class,PropertyFilterMixIn.class);

            HashSet<String> givenFields = new HashSet<>();
            givenFields.add("schemas");
            Collections.addAll(givenFields,fieldsToReturn);
            String[] finalFieldsToReturn = givenFields.toArray(new String[givenFields.size()]);

            FilterProvider filters = new SimpleFilterProvider()
                    .addFilter("filter properties by name",SimpleBeanPropertyFilter.filterOutAllExcept(
                                    finalFieldsToReturn));
            return mapper.writer(filters);
        }
        return mapper.writer();
    }

@Bean
public SimpleFilterProvider filterProvider() {
    final Set<String> set = ImmutableSet.of(
            "indexProtocol","indexPort","serviceProtocol","servicePort","productType","productTypeRegex","indexErrorMessage","plaintextPassword","currentPassword"
    );

    final SimpleBeanPropertyFilter.SerializeExceptFilter filter = new SimpleBeanPropertyFilter.SerializeExceptFilter(set);

    return new SimpleFilterProvider(ImmutableMap.of("configurationFilter",filter));
}

protected void configureJSONExporter() {
    mapper = new ObjectMapper();

    // configure
    mapper.enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS);

    // set Mixins
    mapper.addMixInAnnotations(BaseNode.class,JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(TaskNode.class,JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(EventNode.class,JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(InfoNode.class,JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(SymLinkNode.class,JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(UrlResNode.class,JsonExportBaseNodeMixin.class);

    // add additional filters
    mapper.addMixInAnnotations(Object.class,PropertyFilterMixIn.class);
    String[] ignorableFieldNames = {"importTmpId","fullSrc","srcName"};
    FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name",SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));
    writer = mapper.writer(filters);
}

@SuppressWarnings("deprecation")
@RequestMapping(value = "/api/path",method = RequestMethod.GET)
@ResponseBody
public String getPathsForProfile(Model model,String profileIdentifier,@RequestParam(value = "typeFilter[]",required = false) String[] typeFilter,@RequestParam(value = "clientUUID",defaultValue = Constants.PROFILE_CLIENT_DEFAULT_ID) String clientUUID) throws Exception {
    int profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
    List<EndpointOverride> paths = PathOverrideService.getInstance().getPaths(profileId,clientUUID,typeFilter);

    HashMap<String,Object> jqReturn = Utils.getJqgridJSON(paths,"paths");

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.addMixInAnnotations(Object.class,ViewFilters.GetPathFilter.class);
    String[] ignorableFieldNames = {"possibleEndpoints","enabledEndpoints"};
    FilterProvider filters = new SimpleFilterProvider().addFilter("Filter properties from the PathController GET",SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));

    ObjectWriter writer = objectMapper.writer(filters);

    return writer.writeValueAsstring(jqReturn);
}

@RequestMapping(value = "/api/path/test",method = RequestMethod.GET)
@ResponseBody
public String testPath(@RequestParam String url,@RequestParam String profileIdentifier,@RequestParam Integer requestType) throws Exception {
    int profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);

    List<EndpointOverride> trySelectedRequestPaths = PathOverrideService.getInstance().getSelectedpaths(Constants.OVERRIDE_TYPE_REQUEST,ClientService.getInstance().findClient("-1",profileId),ProfileService.getInstance().findProfile(profileId),url,requestType,true);

    HashMap<String,Object> jqReturn = Utils.getJqgridJSON(trySelectedRequestPaths,SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));

    ObjectWriter writer = objectMapper.writer(filters);

    return writer.writeValueAsstring(jqReturn);
}

ObjectWriter newWriter(final boolean locationInfo,final boolean properties,final boolean compact) {
    final SimpleFilterProvider filters = new SimpleFilterProvider();
    final Set<String> except = new HashSet<>(2);
    if (!locationInfo) {
        except.add(this.getPropertNameForSource());
    }
    if (!properties) {
        except.add(this.getPropertNameForContextMap());
    }
    except.add(this.getPropertNameForNanoTime());
    filters.addFilter(Log4jLogEvent.class.getName(),SimpleBeanPropertyFilter.serializeAllExcept(except));
    final ObjectWriter writer = this.newObjectMapper().writer(compact ? this.newCompactPrinter() : this.newPrettyPrinter());
    return writer.with(filters);
}

public static String objectToJsonExclude(Object data,String filterName,String  ...exName) {
    try {
          SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter
                  .serializeAllExcept(exName);
          FilterProvider filters = new SimpleFilterProvider()
                  .addFilter(filterName,theFilter);

          return MAPPER.writer(filters).writeValueAsstring(data);
} catch (JsonProcessingException e) {
    e.printstacktrace();
}
    return null;
  }

@ExceptionHandler(CerebroException.class)
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public String getErrorCode(final CerebroException exception) throws IOException {
    LOGGER.error("Service error",exception);
    ObjectMapper objectMapper = new ObjectMapper();
    FilterProvider filterProvider = new SimpleFilterProvider().addFilter("responseFilter",SimpleBeanPropertyFilter.filterOutAllExcept("errorCode","errorMessage"));
    objectMapper.setFilterProvider(filterProvider);
    return objectMapper.writeValueAsstring(exception);
}

@Test
public void filters() throws JsonProcessingException {
    ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json()
            .filters(new SimpleFilterProvider().setFailOnUnkNownId(false)).build();
    JacksonFilteredBean bean = new JacksonFilteredBean("value1","value2");
    String output = objectMapper.writeValueAsstring(bean);
    assertthat(output,containsstring("value1"));
    assertthat(output,containsstring("value2"));

    objectMapper = Jackson2ObjectMapperBuilder.json().filters((new SimpleFilterProvider().setFailOnUnkNownId(false)
            .setDefaultFilter(SimpleBeanPropertyFilter.serializeAllExcept("property2")))).build();
    output = objectMapper.writeValueAsstring(bean);
    assertthat(output,not(containsstring("value2")));
}

@Bean
public DynamicFilterResponseBodyAdvice propertyFilterResponseBodyAdvice() {
  DynamicFilterResponseBodyAdvice advice = new DynamicFilterResponseBodyAdvice();
  advice.addResolvers(new DynamicFilterResolver<WithoutAB>() {
    @Override
    public PropertyFilter apply(WithoutAB t) {
      return SimpleBeanPropertyFilter.serializeAllExcept("a","b");
    }
  });
  return advice;
}

public static String render(Object obj) throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
    mapper.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenopacketClass",SimpleBeanPropertyFilter.serializeAll()));
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
    return writer.writeValueAsstring(obj);
}

private static ObjectNode generateSchema() throws JsonMappingException {
    ObjectMapper m = new ObjectMapper();
    m.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenopacketClass",SimpleBeanPropertyFilter.serializeAll()));
    SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
    m.acceptJsonFormatVisitor(m.constructType(Phenopacket.class),visitor);
    JsonSchema jsonSchema = visitor.finalSchema();
    return (ObjectNode) m.valuetoTree(jsonSchema);
}

private static String prettyJsonString(Object obj)
        throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenopacketClass",SimpleBeanPropertyFilter.serializeAll()));
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
    return writer.writeValueAsstring(obj);
}

private void makeSchema(Class c,String fn) throws IOException {

        ObjectMapper m = new ObjectMapper();
        m.setFilterProvider(new SimpleFilterProvider().addFilter(
                "PhenopacketClass",SimpleBeanPropertyFilter.serializeAll()));
        SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
        m.acceptJsonFormatVisitor(m.constructType(c),visitor);
        JsonSchema jsonSchema = visitor.finalSchema();
        String s = m.writerWithDefaultPrettyPrinter().writeValueAsstring(
                jsonSchema);
        System.out.println(s);
        writeSchema(fn,s);
    }

private void makeSchema(Class<?> c,String fn) throws IOException {
    // Protobuf cannot serialize freeform Objects
    ObjectMapper mapper = new ProtobufMapper()
            .setFilterProvider(new SimpleFilterProvider().addFilter(
                    "PhenopacketClass",SimpleBeanPropertyFilter.serializeAllExcept("@context")));
    // Todo: make these compile and pass!
    ProtobufSchemaGenerator gen = new ProtobufSchemaGenerator();
    mapper.acceptJsonFormatVisitor(c,gen);
    ProtobufSchema schemaWrapper = gen.getGeneratedSchema();
    String s = schemaWrapper.getSource().toString();
    writeSchema(fn,s);

}

public ObjectMapperExceptField(Class<?> targetClass,String property) {
    super();
    SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter.serializeAllExcept(property);
    FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter",theFilter);
    addMixInAnnotations(targetClass,PropertyFilterMixIn.class);
    setFilters(filters);
}

public static String writeGroup(SymbolGroup group) throws JsonProcessingException {
    SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.serializeAllExcept("symbolAmount");
    FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name",filter);
    ObjectMapper mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Object.class,PropertyFilterMixIn.class);
    return mapper.writer(filters).writeValueAsstring(group);
}

@Override
public void initialize(Bootstrap<SystemApiConfiguration> maintenanceConfigurationBootstrap) {
    ObjectMapper mapper = maintenanceConfigurationBootstrap.getobjectMapper();
    mapper.addMixInAnnotations(NetworkInterface.class,NetworkInterfaceMixin.class);
    FilterProvider filterProvider = new SimpleFilterProvider()
            .addFilter("networkInterface filter",SimpleBeanPropertyFilter.serializeAllExcept("name","displayName","inetAddresses","interfaceAddresses","mtu","subInterfaces"));
    mapper.setFilters(filterProvider);
}

public static FilterProvider getFilterProvider(final String... fieldsToExclude) {
    if (null == fieldsToExclude || fieldsToExclude.length == 0) {
        // Use the 'serializeAllExcept' method so it is compatible with older versions of jackson
        return new SimpleFilterProvider()
                .addFilter(FILTER_FIELDS_BY_NAME,(BeanPropertyFilter) SimpleBeanPropertyFilter.serializeAllExcept());
    }

    return new SimpleFilterProvider()
            .addFilter(FILTER_FIELDS_BY_NAME,(BeanPropertyFilter) SimpleBeanPropertyFilter.serializeAllExcept(fieldsToExclude));
}

protected MappingJacksonValue buildresponse(Object resource,String attributes) {

        MappingJacksonValue wrapper = new MappingJacksonValue(resource);
        if (!Strings.isNullOrEmpty(attributes)) {
            Set<String> attributesSet = extractAttributes(attributes);
            FilterProvider filterProvider = new SimpleFilterProvider().addFilter(
                    "attributeFilter",SimpleBeanPropertyFilter.filterOutAllExcept(attributesSet)
            );
            wrapper.setFilters(filterProvider);
        }
        return wrapper;
    }

/**
 * Convert a {@link Marathon} object to Json.
 *
 * @param marathon
 * @return
 * @throws IOException
 */
@Override
public String serializeMarathon(Marathon marathon) throws IOException {
    FilterProvider filters = new SimpleFilterProvider().addFilter("filterConstraints",SimpleBeanPropertyFilter.serializeAllExcept("constraints"));

    String json = objectMapper.setFilterProvider(filters).writeValueAsstring(marathon);
    return json;
}

@Override
public String process(String textToProcess,JsonNode configuration) throws Throwable {
    HttpResponseForAvailability httpResponseForAvailability = JsonConverter.jsonStringToObject(textToProcess,HttpResponseForAvailability.class);

    ObjectMapper mapper = new ObjectMapper();
    String[] ignorableFieldNames = { "httpStatusCode"};
    FilterProvider filters = new SimpleFilterProvider()
            .addFilter("httpFilter",SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));
    ObjectWriter writer = mapper.writer(filters);
    return  writer.writeValueAsstring(httpResponseForAvailability);
}

@Override
public String process(String textToProcess,JsonNode configuration) throws Throwable {
    HttpResponseForAvailability httpResponseForAvailability =
            JsonConverter.jsonStringToObject(textToProcess,HttpResponseForAvailability.class);

    ObjectMapper mapper = new ObjectMapper();
    String[] ignorableFieldNames = { "body"};
    FilterProvider filters = new SimpleFilterProvider()
            .addFilter("httpFilter",SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));
    ObjectWriter writer = mapper.writer(filters);
    return writer.writeValueAsstring(httpResponseForAvailability);
}

@Test
public void updatetest() throws Exception {

    EntrezGene gene = new EntrezGene(7L,"GeneG",SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnkNownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    mockmvc.perform(post(BASE_URL)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isCreated());

    gene.setPrimaryGenesymbol("TEST_GENE");

    mockmvc.perform(put(BASE_URL + "/{id}",7L)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$",is(7)))
            .andExpect(jsonPath("$.primaryGenesymbol",is("TEST_GENE")));

    mockmvc.perform(get(BASE_URL + "/{id}",7L))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.entrezGeneId",is("TEST_GENE")));

    geneRepository.delete(7L);

}

@Test
public void posttest() throws Exception {
    EntrezGene
            gene = new EntrezGene(6L,SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnkNownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mockmvc.perform(post(BASE_URL)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isMethodNotAllowed());
}

@Test
public void puttest() throws Exception {
    EntrezGene
            gene = new EntrezGene(6L,SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnkNownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mockmvc.perform(put(BASE_URL + "/1")
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isMethodNotAllowed());
}

public static String toXml(final Ds3ObjectList objects,final boolean isBulkPut) {
    if (isBulkPut) {
        return XmlOutput.toXml(objects);
    }
    final FilterProvider filters = new SimpleFilterProvider().addFilter("sizefilter",SimpleBeanPropertyFilter.serializeAllExcept("Size"));
    return XmlOutput.toXml(objects,filters);
}

public HappyDroidobjectMapper() {
    super();

    configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
    happyModules = new SimpleModule();
    happyModules.addSerializer(new StackTraceSerializer());
    registerModule(happyModules);

    setFilters(new SimpleFilterProvider().addFilter("HappyDroidServiceObject",SimpleBeanPropertyFilter.serializeAllExcept("id")));
}

/**
 * Enables/disables redaction support when serializing complex objects.  Redacted fields/properties marked
 * with the @LogRedact annotation will be output as a string with the value "{@code <REDACTED>}".
 *
 * @param redactEnabled - true to filter out redacted fields
 *
 * @since 1.1.0
 */
public void setRedactEnabled(final boolean redactEnabled) {
    final SimpleFilterProvider simpleFilterProvider = new SimpleFilterProvider();
    if (redactEnabled) {
        simpleFilterProvider.addFilter(RedactionFilter.REDACTION_FILTER_ID,new RedactionFilter(!_redactNull));
    } else {
        simpleFilterProvider.addFilter(RedactionFilter.REDACTION_FILTER_ID,SimpleBeanPropertyFilter.serializeAllExcept(Collections.<String>emptySet()));
    }
    _objectMapper.setFilterProvider(simpleFilterProvider);
    _redactEnabled = redactEnabled;
}

/**
 * Create a JSON serializer for these validation results.
 * @param results
 */
public JsonSerializer (FeedValidationResultSet results) {
    super(results);
    mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Rectangle2D.class,Rectangle2DMixIn.class);
    SimpleModule deser = new SimpleModule();
    deser.addDeserializer(Rectangle2D.class,new Rectangle2DDeserializer());
    mapper.registerModule(deser);
    SimpleFilterProvider filters = new SimpleFilterProvider();
    filters.addFilter("bBox","north"));
    writer = mapper.writer(filters);
}

@Override
@SuppressWarnings("unchecked")
public PropertyFilter findPropertyFilter(final Object filterId,final Object valuetoFilter) {
    if (filterId instanceof String) {
        final String id = (String) filterId;

        // FilterId should represent a class only in case of root entity is marshalled.
        if (id.equals(root.getEntityClass().getName())) {
            stack.clear();
            return stack.push(root);
        }

        while (!stack.isEmpty()) {
            final FilteringPropertyFilter peek = stack.peek();
            final FilteringPropertyFilter subfilter = peek.findSubfilter(id);

            if (subfilter != null) {
                stack.push(subfilter);

                // Need special handling for maps here - map keys can be filtered as well so we just say that every key is
                // allowed.
                if (valuetoFilter instanceof Map) {
                    final Map<String,?> map = (Map<String,?>) valuetoFilter;
                    return new FilteringPropertyFilter(Map.class,map.keySet(),Collections.emptyMap());
                }
                return subfilter;
            } else {
                stack.pop();
            }
        }
    }
    return SimpleBeanPropertyFilter.filterOutAllExcept();
}

@Override
public String getBody() throws Exception {
    Set<String> properties = new HashSet<String>();
    for (String field : fields) {
        properties.add(field);
    }
    SimpleBeanPropertyFilter filter = new SimpleBeanPropertyFilter.FilterExceptFilter(properties);
    SimpleFilterProvider provider = new SimpleFilterProvider();
    provider.addFilter("update inventory request filter",filter);
    return mapper.writer(provider).writeValueAsstring(inventory);
}

public HerokudiscoveryStrategy(ILogger logger,Map<String,Comparable> properties) {
  super(logger,properties);

  String serviceNamesProp = getorNull(new SimplePropertyDeFinition("serviceNames",PropertyTypeConverter.STRING));
  if (serviceNamesProp == null) {
    String formationName = System.getenv("HEROKU_DNS_FORMATION_NAME");
    if (formationName == null) {
      throw new IllegalArgumentException("You must enable Heroku DNS Service discovery for this Hazelcast plugin to work!");
    } else {
      this.serviceNames = Collections.unmodifiableCollection(Arrays.asList(formationName));
    }
  } else {
    List<String> serviceNamesList = new ArrayList<>();
    for (String serviceName : serviceNamesProp.split(";")) {
      String appName = System.getenv("HEROKU_DNS_APP_NAME");
      if (appName == null) {
        throw new IllegalArgumentException("You must enable Heroku DNS Service discovery for this Hazelcast plugin to work!");
      } else {
        serviceNamesList.add(serviceName + "." + appName);
      }
    }
    this.serviceNames = Collections.unmodifiableCollection(serviceNamesList);
  }

  String mergeDelay = getorNull(new SimplePropertyDeFinition("mergeDelay",PropertyTypeConverter.STRING));
  System.setProperty("hazelcast.merge.first.run.delay.seconds",mergeDelay == null ? "20" : mergeDelay);

  // Todo parse /etc/heroku/space-topology.json instead,// but that should go in a separate library
  Security.setProperty("networkaddress.cache.ttl","20");
  Security.setProperty("networkaddress.cache.negative.ttl","0");
}

public ConsuldiscoveryFactory() {
    List<PropertyDeFinition> properties = new ArrayList<>();
    properties.add(new SimplePropertyDeFinition("host",PropertyTypeConverter.STRING));
    properties.add(new SimplePropertyDeFinition("port",PropertyTypeConverter.INTEGER));
    properties.add(new SimplePropertyDeFinition("name",PropertyTypeConverter.STRING));
    this.propertyDeFinitions = Collections.unmodifiableCollection(properties);
}

public ConsuldiscoveryFactory() {
    List<PropertyDeFinition> properties = new ArrayList<>();
    properties.add(new SimplePropertyDeFinition("host",PropertyTypeConverter.STRING));
    this.propertyDeFinitions = Collections.unmodifiableCollection(properties);
}

private static PropertyDeFinition property(String key,PropertyTypeConverter typeConverter,ValueValidator valueValidator) {
    return new SimplePropertyDeFinition(key,true,typeConverter,valueValidator);
}

private static PropertyDeFinition property(String key,TypeConverter typeConverter) {
    return new SimplePropertyDeFinition(key,typeConverter);
}

private static PropertyDeFinition property(String key,valueValidator);
}

private static PropertyDeFinition property(String key,valueValidator);
}

private static PropertyDeFinition property(String key,typeConverter);
}

@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder,boolean isOnTheFly) {
  if (!(holder.getFile() instanceof PropertiesFileImpl)) {
    return PsiElementVisitor.EMPTY_VISITOR;
  }
  final PropertiesCodeStyleSettings codeStyleSettings = PropertiesCodeStyleSettings.getInstance(holder.getProject());
  final char codeStylekeyvalueDelimiter = codeStyleSettings.KEY_VALUE_DELIMITER;
  return new PsiElementVisitor() {
    @Override
    public void visitElement(PsiElement element) {
      if (element instanceof PropertyImpl) {
        final Character delimiter = ((PropertyImpl)element).getkeyvalueDelimiter();
        if (delimiter != null && !delimiter.equals(codeStylekeyvalueDelimiter)) {
          holder.registerProblem(element,PropertiesBundle.message("wrong.property.key.value.delimiter.inspection.display.name"),new ReplacekeyvalueDelimiterQuickFix(element));
        }
      }
    }
  };
}

/**
 * We need special logic to determine when it should insert "=" at the end of the options
 */
@NotNull
private static LookupElementBuilder addInsertHandler(final Editor editor,final LookupElementBuilder builder,String suffix) {
    return builder.withInsertHandler((context,item) -> {
        // enforce using replace select char as we want to replace any existing option
        if (context.getCompletionChar() == Lookup.norMAL_SELECT_CHAR) {
            int endSelectOffBy = 0;
            if (context.getFile() instanceof PropertiesFileImpl) {
                //if it's a property file the PsiElement does not start and end with an quot
                endSelectOffBy = 1;
            }
            final char text = context.getDocument().getChaRSSequence().charat(context.getSelectionEndOffset() - endSelectOffBy);
            if (text != '=') {
                EditorModificationUtil.insertStringAtCaret(editor,"=");
            }
        } else if (context.getCompletionChar() == Lookup.REPLACE_SELECT_CHAR) {
            // we still want to keep the suffix because they are other options
            String value = suffix;
            int pos = value.indexOf("&");
            if (pos > -1) {
                // strip out first part of suffix until next option
                value = value.substring(pos);
            }
            EditorModificationUtil.insertStringAtCaret(editor,"=" + value);
            // and move cursor back again
            int offset = -1 * value.length();
            EditorModificationUtil.moveCaretRelatively(editor,offset);
        }

    });
}

@NotNull
public Structureviewbuilder getStructureviewbuilder(final PsiFile psiFile) {
  return new Structureviewbuilder() {
    @NotNull
    public StructureView createStructureView(FileEditor fileEditor,@NotNull Project project) {
      return new PropertiesFileStructureViewComponent(project,(PropertiesFileImpl)psiFile,fileEditor);
    }
  };
}

@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder,boolean isOnTheFly) {
  return new PsiElementVisitor() {
    @Override
    public void visitFile(PsiFile file) {
      final PropertiesFile propertiesFile = PropertiesImplUtil.getPropertiesFile(file);
      if (!(propertiesFile instanceof PropertiesFileImpl)) {
        return;
      }
      for (AlphaUnsortedPropertiesFileinspectionSuppressor filter : AlphaUnsortedPropertiesFileinspectionSuppressor.EP_NAME.getExtensions()) {
        if (filter.suppressinspectionFor(propertiesFile)) {
          return;
        }
      }
      final ResourceBundle resourceBundle = propertiesFile.getResourceBundle();
      final String resourceBundleBaseName = resourceBundle.getBaseName();
      if (!isResourceBundleAlphaSortedExceptOneFile(resourceBundle,propertiesFile)) {
        final List<PropertiesFile> allFiles = resourceBundle.getPropertiesFiles();
        holder.registerProblem(file,String.format(MESSAGE_TEMPLATE_WHOLE_RESOURCE_BUNDLE,resourceBundleBaseName),ProblemHighlightType.INFO,new PropertiesSorterQuickFix(true,allFiles.toArray(new PropertiesFile[allFiles.size()])));
        return;
      }
      if (!propertiesFile.isAlphaSorted()) {
        holder.registerProblem(file,"Properties file is unsorted",propertiesFile));
      }
    }
  };
}

private static boolean isResourceBundleAlphaSortedExceptOneFile(final @NotNull ResourceBundle resourceBundle,final @NotNull PropertiesFile exceptedFile) {
  for (PropertiesFile file : resourceBundle.getPropertiesFiles()) {
    if (!(file instanceof PropertiesFileImpl)) {
      return true;
    }
    if (!file.equals(exceptedFile) && !file.isAlphaSorted()) {
      return false;
    }
  }
  return true;
}

@NotNull
public Structureviewbuilder getStructureviewbuilder(final PsiFile psiFile) {
  return new Structureviewbuilder() {
    @NotNull
    public StructureView createStructureView(FileEditor fileEditor,Project project) {
      return new PropertiesFileStructureViewComponent(project,fileEditor);
    }
  };
}

public PropertiesFileStructureViewComponent(Project project,PropertiesFileImpl propertiesFile,FileEditor editor) {
  super(project,editor,new PropertiesFileStructureviewmodel(propertiesFile));
  myPropertiesFile = propertiesFile;
}

protected PropertiesFileStructureViewElement(PropertiesFileImpl propertiesFile) {
  super(propertiesFile);
}

public PropertiesFileStructureviewmodel(final PropertiesFileImpl root) {
  super(root);
  myPropertiesFile = root;
  String separator = PropertiesSeparatorManager.getInstance(root.getProject()).getSeparator(root.getResourceBundle());
  myByWordPrefixesGrouper = new GroupByWordPrefixes(separator);
}

public PsiFile createFile(FileViewProvider viewProvider) {
  return new PropertiesFileImpl(viewProvider);
}

public PropertiesFileStructureViewComponent(Project project,new PropertiesFileStructureviewmodel(propertiesFile));
  myPropertiesFile = propertiesFile;
}

protected PropertiesFileStructureViewElement(PropertiesFileImpl propertiesFile) {
  super(propertiesFile);
}

public PropertiesFileStructureviewmodel(final PropertiesFileImpl root) {
  super(root);
  myPropertiesFile = root;
  String separator = PropertiesSeparatorManager.getInstance().getSeparator(root.getProject(),root.getVirtualFile());
  myGroupByWordPrefixes = new GroupByWordPrefixes(separator);
}

public PsiFile createFile(FileViewProvider viewProvider) {
  return new PropertiesFileImpl(viewProvider);
}

public ProblemDescriptor[] checkFile(@NotNull PsiFile file,@NotNull final inspectionManager manager,final boolean isOnTheFly) {
  if (!(file instanceof PropertiesFile)) return null;
  final List<IProperty> properties = ((PropertiesFile)file).getProperties();
  final List<ProblemDescriptor> descriptors = new SmartList<ProblemDescriptor>();
  for (IProperty property : properties) {
    ProgressManager.checkCanceled();
    final PropertyImpl propertyImpl = (PropertyImpl)property;
    for (ASTNode node : ContainerUtil.ar(propertyImpl.getKeyNode(),propertyImpl.getValueNode())) {
      if (node != null) {
        PsiElement key = node.getPsi();
        TextRange textRange = getTrailingSpaces(key,myIgnoreVisibleSpaces);
        if (textRange != null) {
          descriptors.add(manager.createProblemDescriptor(key,textRange,"Trailing spaces",ProblemHighlightType.GENERIC_ERROR_OR_WARNING,true,new RemoveTrailingSpacesFix(myIgnoreVisibleSpaces)));
        }
      }
    }
  }
  return descriptors.toArray(new ProblemDescriptor[descriptors.size()]);
}

@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder,boolean isOnTheFly) {
  if (!(holder.getFile() instanceof PropertiesFileImpl)) {
    return PsiElementVisitor.EMPTY_VISITOR;
  }
  final PropertiesCodeStyleSettings codeStyleSettings = PropertiesCodeStyleSettings.getInstance(holder.getProject());
  final char codeStylekeyvalueDelimiter = codeStyleSettings.KEY_VALUE_DELIMITER;
  return new PsiElementVisitor() {
    @Override
    public void visitElement(PsiElement element) {
      if (element instanceof PropertyImpl) {
        final Character delimiter = ((PropertyImpl)element).getkeyvalueDelimiter();
        if (delimiter != null && !delimiter.equals(codeStylekeyvalueDelimiter)) {
          holder.registerProblem(element,PropertiesBundle.message("wrong.property.key.value.delimiter.inspection.display.name"),new ReplacekeyvalueDelimiterQuickFix(element));
        }
      }
    }
  };
}

public void annotate(@NotNull PsiElement element,@NotNull AnnotationHolder holder) {
  if (!(element instanceof IProperty)) return;
  final Property property = (Property)element;
  PropertiesFile propertiesFile = property.getPropertiesFile();
  Collection<IProperty> others = propertiesFile.findPropertiesByKey(property.getUnescapedKey());
  ASTNode keyNode = ((PropertyImpl)property).getKeyNode();
  if (others.size() != 1) {
    Annotation annotation = holder.createErrorAnnotation(keyNode,PropertiesBundle.message("duplicate.property.key.error.message"));
    annotation.registerFix(PropertiesQuickFixFactory.getInstance().createRemovePropertyFix(property));
  }

  highlightTokens(property,keyNode,holder,new PropertiesHighlighter());
  ASTNode valueNode = ((PropertyImpl)property).getValueNode();
  if (valueNode != null) {
    highlightTokens(property,valueNode,new PropertiesValueHighlighter());
  }
}

public void annotate(@NotNull PsiElement element,PropertiesBundle.message("duplicate.property.key.error.message"));
    annotation.registerFix(new RemovePropertyFix(property));
  }

  highlightTokens(property,new PropertiesValueHighlighter());
  }
}

public void testNonDefaultkeyvalueDelimiter() {
  final PropertiesCodeStyleSettings codeStyleSettings = PropertiesCodeStyleSettings.getInstance(getProject());
  codeStyleSettings.KEY_VALUE_DELIMITER = ':';
  final PropertyImpl property = (PropertyImpl)PropertiesElementFactory.createProperty(getProject(),"xxx","yyy");
  final Character delimiter = property.getkeyvalueDelimiter();
  assertNotNull(delimiter);
  assertEquals(':',(char)delimiter);
  assertEquals("xxx:yyy",property.getPsiElement().getText());
  codeStyleSettings.KEY_VALUE_DELIMITER = PropertiesCodeStyleSettings.DEFAULT_KEY_VALUE_DELIMITER;
}

@Nullable
private static TextRange getTrailingSpaces(PsiElement element,boolean ignoreVisibleTrailingSpaces) {
  String key = element.getText();
  if (ignoreVisibleTrailingSpaces) {
    for (int i = key.length() - 1; i > -1; i--) {
      if (key.charat(i) != ' ' && key.charat(i) != '\t') {
        return i == key.length() - 1 ? null : new TextRange(i + 1,key.length());
      }
    }
    return element.getTextRange();
  } else {
    return PropertyImpl.trailingSpaces(key);
  }
}

public void applyFix(@NotNull Project project,@NotNull ProblemDescriptor descriptor) {
  PsiElement element = descriptor.getPsiElement();
  PsiElement parent = element == null ? null : element.getParent();
  if (!(parent instanceof PropertyImpl)) return;
  TextRange textRange = getTrailingSpaces(element,myIgnoreVisibleSpaces);
  if (textRange != null) {
    Document document = PsiDocumentManager.getInstance(project).getDocument(element.getContainingFile());
    TextRange docRange = textRange.shiftRight(element.getTextRange().getStartOffset());
    document.deleteString(docRange.getStartOffset(),docRange.getEndOffset());
  }
}

public ApplicationEnvironment(CoreApplicationEnvironment appEnvironment) {
  appEnvironment.registerFileType(PropertiesFileType.INSTANCE,"properties");
  appEnvironment.addExplicitExtension(SyntaxHighlighterFactory.LANGUAGE_FACTORY,PropertiesLanguage.INSTANCE,new PropertiesSyntaxHighlighterFactory());
  appEnvironment.addExplicitExtension(LanguageParserDeFinitions.INSTANCE,new PropertiesParserDeFinition());
  appEnvironment.addExtension(FileBasedindexExtension.EXTENSION_POINT_NAME,new XmlPropertiesIndex());
  appEnvironment.addExtension(StubIndexExtension.EP_NAME,new PropertyKeyIndex());

  appEnvironment.registerapplicationservice(PropertiesQuickFixFactory.class,new EmptyPropertiesQuickFixFactory());
  appEnvironment.registerapplicationservice(PropertiesRefactoringSettings.class,new PropertiesRefactoringSettings());
  appEnvironment.addExplicitExtension(LanguageAnnotators.INSTANCE,new PropertiesAnnotator());
  appEnvironment.addExplicitExtension(LanguageFindUsages.INSTANCE,new PropertiesFindUsagesProvider());

  appEnvironment.addExplicitExtension(LanguageASTFactory.INSTANCE,new PropertiesASTFactory());
  appEnvironment.addExplicitExtension(LanguageFolding.INSTANCE,new PropertiesFoldingBuilder());
  appEnvironment.addExplicitExtension(ElementManipulators.INSTANCE,PropertyImpl.class,new PropertyManipulator());
  appEnvironment.addExplicitExtension(ElementManipulators.INSTANCE,PropertyKeyImpl.class,new PropertyKeyManipulator());
  appEnvironment.addExplicitExtension(ElementManipulators.INSTANCE,PropertyValueImpl.class,new PropertyValueManipulator());

  final StubElementTypeHolderEP stubElementTypeHolderBean = new StubElementTypeHolderEP();
  stubElementTypeHolderBean.holderClass = PropertiesElementTypes.class.getName();
  appEnvironment.addExtension(StubElementTypeHolderEP.EP_NAME,stubElementTypeHolderBean);

  appEnvironment.addExplicitExtension(LanguageCommenters.INSTANCE,new PropertiesCommenter());
  appEnvironment.addExplicitExtension(Idindexers.INSTANCE,PropertiesFileType.INSTANCE,new PropertiesIdindexer());
  appEnvironment.addExplicitExtension(TodoIndexers.INSTANCE,new PropertiesTodoIndexer());

  appEnvironment.addExtension(IconProvider.EXTENSION_POINT_NAME,new XmlPropertiesIconProvider());
}

@Override
public PropertyImpl handleContentChange(@NotNull PropertyImpl element,@NotNull TextRange range,String newContent) throws IncorrectOperationException {
  TextRange valueRange = getRangeInElement(element);
  final String oldText = element.getText();
  String newText = oldText.substring(0,range.getStartOffset()) + newContent + oldText.substring(range.getEndOffset());
  element.setValue(newText.substring(valueRange.getStartOffset()).replaceAll("([^\\s])\n","$1 \n"));  // add explicit space before \n
  return element;
}

@NotNull
@Override
public TextRange getRangeInElement(@NotNull PropertyImpl element) {
  ASTNode valueNode = element.getValueNode();
  if (valueNode == null) return TextRange.from(element.getTextLength(),0);
  TextRange range = valueNode.getTextRange();
  return TextRange.from(range.getStartOffset() - element.getTextRange().getStartOffset(),range.getLength());
}

@NotNull
public PsiElement createElement(ASTNode node) {
  final IElementType type = node.getElementType();
  if (type == PropertiesElementTypes.PROPERTY) {
    return new PropertyImpl(node);
  }
  else if (type == PropertiesElementTypes.PROPERTIES_LIST) {
    return new PropertiesListImpl(node);
  }
  throw new AssertionError("Alien element type [" + type + "]. Can't create Property PsiElement for that.");
}

@NotNull
@Override
public Tokenizer getTokenizer(PsiElement element) {
  if (element instanceof PropertyValueImpl) {
    return myPropertyValuetokenizer;
  }
  if (element instanceof PropertyImpl) {
    return myPropertyTokenizer;
  }
  return super.getTokenizer(element);
}

@Override
public PropertyImpl handleContentChange(PropertyImpl element,TextRange range,"$1 \n"));  // add explicit space before \n
  return element;
}

@Override
public TextRange getRangeInElement(PropertyImpl element) {
  ASTNode valueNode = element.getValueNode();
  if (valueNode == null) return TextRange.from(element.getTextLength(),range.getLength());
}

public void applyFix(@NotNull Project project,@NotNull ProblemDescriptor descriptor) {
  PsiElement element = descriptor.getPsiElement();
  PsiElement parent = element == null ? null : element.getParent();
  if (!(parent instanceof PropertyImpl)) return;
  TextRange textRange = getTrailingSpaces(element);
  if (textRange != null) {
    Document document = PsiDocumentManager.getInstance(project).getDocument(element.getContainingFile());
    TextRange docRange = textRange.shiftRight(element.getTextRange().getStartOffset());
    document.deleteString(docRange.getStartOffset(),docRange.getEndOffset());
  }
}

@NotNull
public PsiElement createElement(ASTNode node) {
  final IElementType type = node.getElementType();
  if (type == PropertiesElementTypes.PROPERTY) {
    return new PropertyImpl(node);
  }
  else if (type == PropertiesElementTypes.PROPERTIES_LIST) {
    return new PropertiesListImpl(node);
  }
  throw new AssertionError("Alien element type [" + type + "]. Can't create Property PsiElement for that.");
}

@Override
public void invoke(@NotNull Project project,@NotNull PsiFile file,@NotNull PsiElement element,@NotNull PsiElement endElement) {
  ((PropertyImpl) element).replacekeyvalueDelimiterWithDefault();
}

public Property createPsi(@NotNull final PropertyStub stub) {
  return new PropertyImpl(stub,this);
}

public void indexStub(@NotNull final PropertyStub stub,@NotNull final IndexSink sink) {
  sink.occurrence(PropertyKeyIndex.KEY,PropertyImpl.unescape(stub.getKey()));
}

public void tokenize(@NotNull PropertyImpl element,TokenConsumer consumer) {
  String key = element.getKey();
  consumer.consumetoken(element,key,TextRange.allOf(key),Propertiessplitter.getInstance());
}

private static TextRange getTrailingSpaces(PsiElement element) {
  String key = element.getText();

  return PropertyImpl.trailingSpaces(key);
}

public Property createPsi(@NotNull final PropertyStub stub) {
  return new PropertyImpl(stub,this);
}

public void indexStub(@NotNull final PropertyStub stub,PropertyImpl.unescape(stub.getKey()));
}