Index: engine/src/main/java/org/hippoecm/repository/FacetedNavigationEngineImpl.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- engine/src/main/java/org/hippoecm/repository/FacetedNavigationEngineImpl.java	(revision 57427)
+++ engine/src/main/java/org/hippoecm/repository/FacetedNavigationEngineImpl.java	(revision )
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2008-2015 Hippo B.V. (http://www.onehippo.com)
+ *  Copyright 2008-2016 Hippo B.V. (http://www.onehippo.com)
  * 
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -514,28 +514,28 @@
                     if(freeSearchInjectedSort != null) {
                         // we already have a sort from the xpath or sql free search. Use this one
                         sort = freeSearchInjectedSort;
-                    } else  if (hitsRequested.getOrderByList().size() > 0) {
+                    } else if (hitsRequested.getOrderByList().size() > 0) {
-                        List<Path> orderPropertiesList = new ArrayList<Path>();
-                        List<Boolean> ascSpecsList = new ArrayList<Boolean>();
-                        for (OrderBy orderBy : hitsRequested.getOrderByList()) {
+                        final int size = hitsRequested.getOrderByList().size();
+                        Path[] orderProperties = new Path[size];
+                        boolean[] orderSpecs = new boolean[size];
+                        String[] orderFunctions = new String[size];
+                        for (int i = 0; i < size; i++) {
+                            final OrderBy orderBy = hitsRequested.getOrderByList().get(i);
                             try {
-                               Name orderByProp = NameFactoryImpl.getInstance().create(orderBy.getName());
+                                Name orderByProp = NameFactoryImpl.getInstance().create(orderBy.getName());
-                               boolean isAscending = !orderBy.isDescending();
-                               orderPropertiesList.add(createPath(orderByProp));
-                               ascSpecsList.add(isAscending);
-                            } catch (IllegalArgumentException e) {
+                                orderProperties[i] = createPath(orderByProp);
+                                orderSpecs[i] = !orderBy.isDescending();
+                                orderFunctions[i] = orderBy.getOrderFunction();
+                            } catch (Exception e) {
-                               log.warn("Skip property '{}' because cannot create a Name for it: {}",orderBy.getName(), e.toString());
+                                log.warn("Skip property '{}' because cannot create a Name for it: {}",orderBy.getName(), e.toString());
+                                // remove 1 element from the arrays
+                                orderProperties = Arrays.copyOf(orderProperties, orderProperties.length - 1);
+                                orderSpecs = Arrays.copyOf(orderSpecs, orderSpecs.length - 1);
+                                orderFunctions = Arrays.copyOf(orderFunctions, orderFunctions.length - 1);
                             }
                         }
-                        if(orderPropertiesList.size() > 0) {
-                            Path[] orderProperties = orderPropertiesList.toArray(new Path[orderPropertiesList.size()]);
-                            boolean[] ascSpecs = new boolean[ascSpecsList.size()];
-                            int i = 0;
-                            for(Boolean b : ascSpecsList) {
-                                ascSpecs[i] = b;
-                                i++;
-                            }
-                            sort = new Sort(createSortFields(orderProperties, ascSpecs, new String[orderProperties.length]));
+                        if(orderProperties.length > 0) {
+                            sort = new Sort(createSortFields(orderProperties, orderSpecs, orderFunctions));
                         }
                     }
 
Index: provider/src/main/java/org/hippoecm/repository/HitsRequested.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- provider/src/main/java/org/hippoecm/repository/HitsRequested.java	(revision 57427)
+++ provider/src/main/java/org/hippoecm/repository/HitsRequested.java	(revision )
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2008-2013 Hippo B.V. (http://www.onehippo.com)
+ *  Copyright 2008-2016 Hippo B.V. (http://www.onehippo.com)
  * 
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -68,12 +68,8 @@
 
     public List<OrderBy> getOrderByList() {
         return this.orderByList;
-    }
-
-    public void addOrderBy(String name, boolean descending) {
-        this.orderByList.add(new OrderBy(name, descending));
     }
-    
+
     public void addOrderBy(List<OrderBy> addOrderByList) {
         if(addOrderByList != null) {
             this.orderByList.addAll(addOrderByList);
Index: modules/src/main/java/org/hippoecm/repository/jackrabbit/facetnavigation/FacetNavigationProvider.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- modules/src/main/java/org/hippoecm/repository/jackrabbit/facetnavigation/FacetNavigationProvider.java	(revision 57427)
+++ modules/src/main/java/org/hippoecm/repository/jackrabbit/facetnavigation/FacetNavigationProvider.java	(revision )
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2010-2015 Hippo B.V. (http://www.onehippo.com)
+ *  Copyright 2010-2016 Hippo B.V. (http://www.onehippo.com)
  * 
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -46,6 +46,10 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static org.hippoecm.repository.jackrabbit.facetnavigation.FacNavNodeType.HIPPOFACNAV_FACETSORTBY;
+import static org.hippoecm.repository.jackrabbit.facetnavigation.FacNavNodeType.HIPPOFACNAV_FACETSORTFUNCTION;
+import static org.hippoecm.repository.jackrabbit.facetnavigation.FacNavNodeType.HIPPOFACNAV_FACETSORTORDER;
+
 public class FacetNavigationProvider extends AbstractFacetNavigationProvider {
 
     private final Logger log = LoggerFactory.getLogger(FacetNavigationProvider.class);
@@ -59,6 +63,7 @@
     Name facetLimit;
     Name facetSortBy;
     Name facetSortOrder;
+    Name facetSortFunction;
     Name facetFilters;
     Name skipResultSetFacedNavigationRoot;
     Name skipResultSetFacetsAvailableName;
@@ -72,9 +77,9 @@
         facetNodeNamesName = resolveName(FacNavNodeType.HIPPOFACNAV_FACETNODENAMES);
 
         facetLimit = resolveName(FacNavNodeType.HIPPOFACNAV_FACETLIMIT);
-        facetSortBy = resolveName(FacNavNodeType.HIPPOFACNAV_FACETSORTBY);
-        facetSortOrder = resolveName(FacNavNodeType.HIPPOFACNAV_FACETSORTORDER);
-        
+        facetSortBy = resolveName(HIPPOFACNAV_FACETSORTBY);
+        facetSortOrder = resolveName(HIPPOFACNAV_FACETSORTORDER);
+        facetSortFunction = resolveName(HIPPOFACNAV_FACETSORTFUNCTION);
         facetFilters = resolveName(FacNavNodeType.HIPPOFACNAV_FILTERS);
         skipResultSetFacedNavigationRoot = resolveName(FacNavNodeType.HIPPOFACNAV_SKIP_RESULTSET_FOR_FACET_NAVIGATION_ROOT);
         skipResultSetFacetsAvailableName = resolveName(FacNavNodeType.HIPPOFACNAV_SKIP_RESULTSET_FOR_FACETS_AVAILABLE);
@@ -114,6 +119,7 @@
         String[] facetNodeNames = getProperty(nodeId, facetNodeNamesName, null);
         String[] sortbys = getProperty(nodeId, facetSortBy, null);
         String[] sortorders = getProperty(nodeId, facetSortOrder, null);
+        String[] sortfunctions = getProperty(nodeId, facetSortFunction, null);
         String[] filters = getProperty(nodeId, facetFilters, null);
         
         // check whether to skip resultset for root faceted navigation node
@@ -137,13 +143,24 @@
 
         List<OrderBy> orderByList = null;
         if(sortbys != null) {
-            orderByList = new ArrayList<OrderBy>();
+            orderByList = new ArrayList<>();
+
-            if(sortorders != null && sortorders.length != sortbys.length) {
+            if (sortorders != null && sortorders.length != sortbys.length) {
-                log.warn("When using multivalued '{}', and '{}', then both should have equal number of values (or delete property "+FacNavNodeType.HIPPOFACNAV_FACETSORTORDER+" at all)", FacNavNodeType.HIPPOFACNAV_FACETSORTBY, FacNavNodeType.HIPPOFACNAV_FACETSORTORDER);
+                log.warn("When using multivalued '{}', and '{}', then both should have equal number of values " +
+                        "(or delete property '{}' at all)", HIPPOFACNAV_FACETSORTBY, HIPPOFACNAV_FACETSORTORDER, HIPPOFACNAV_FACETSORTORDER);
                 // we always need to populate the count
                 populateCount(state, 0);
                 return state;
             }
+
+            if (sortfunctions != null  && sortfunctions.length != sortbys.length) {
+                log.warn("When using multivalued '{}', and '{}', then both should have equal number of values " +
+                        "(or delete property '{}' at all)", HIPPOFACNAV_FACETSORTBY, HIPPOFACNAV_FACETSORTFUNCTION, HIPPOFACNAV_FACETSORTFUNCTION);
+                // we always need to populate the count
+                populateCount(state, 0);
+                return state;
+            }
+
             for(int i = 0; i < sortbys.length; i++) {
                 try {
                     if (sortbys[i].equals("")) {
@@ -151,13 +168,15 @@
                         continue;
                     }
 
-                    Name propertyName = resolveName(NodeNameCodec.encode(sortbys[i]));
+                    final Name propertyName = resolveName(NodeNameCodec.encode(sortbys[i]));
+                    final OrderBy orderBy = new OrderBy(propertyName.toString());
-                    if(sortorders != null && "descending".equals(sortorders[i])) {
+                    if (sortorders != null && "descending".equals(sortorders[i])) {
-                        orderByList.add(new OrderBy(propertyName.toString(), true));
-                    } else {
-                        // default orderby is ascending
-                        orderByList.add(new OrderBy(propertyName.toString()));
+                        orderBy.setDescending("descending".equals(sortorders[i]));
                     }
+                    if (sortfunctions != null) {
+                        orderBy.setOrderFunction(sortfunctions[i]);
+                    }
+                    orderByList.add(orderBy);
                 } catch (IllegalNameException|NamespaceException e) {
                     log.warn("Skipping illegal name \"{}\" as sortby for facet node {} because: ", sortbys[i], nodeId, e.getMessage());
                 }
Index: modules/src/main/java/org/hippoecm/repository/jackrabbit/facetnavigation/FacNavNodeType.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- modules/src/main/java/org/hippoecm/repository/jackrabbit/facetnavigation/FacNavNodeType.java	(revision 57427)
+++ modules/src/main/java/org/hippoecm/repository/jackrabbit/facetnavigation/FacNavNodeType.java	(revision )
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2010-2013 Hippo B.V. (http://www.onehippo.com)
+ *  Copyright 2010-2016 Hippo B.V. (http://www.onehippo.com)
  * 
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -55,9 +55,10 @@
     public static final String HIPPOFACNAV_LEAF = "hippofacnav:leaf";
 
     /**
-     * 
+     *
      */
     public static final String HIPPOFACNAV_FACETSORTBY = "hippofacnav:sortby";
+    public static final String HIPPOFACNAV_FACETSORTFUNCTION = "hippofacnav:sortfunction";
 
     /**
      * 
Index: engine/src/main/resources/hippofacnav.cnd
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- engine/src/main/resources/hippofacnav.cnd	(revision 57427)
+++ engine/src/main/resources/hippofacnav.cnd	(revision )
@@ -1,5 +1,5 @@
 /*
- * Copyright 2007-2009 Hippo
+ * Copyright 2007-2016 Hippo
  *
  * Licensed under the Apache License, Version 2.0 (the  "License");
  * you may not use this file except in compliance with the License.
@@ -37,6 +37,7 @@
 - hippofacnav:facetvalueslimit (long)
 - hippofacnav:sortby (string) multiple
 - hippofacnav:sortorder (string) multiple < 'descending', 'ascending'
+- hippofacnav:sortfunction (string) multiple < 'lower-case', 'normalize'
 - hippofacnav:filters (string) multiple
 - hippofacnav:skipresultsetfacetnavigationroot (boolean)
 - hippofacnav:skipresultsetfacetsavailable (boolean)
Index: provider/src/main/java/org/hippoecm/repository/OrderBy.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- provider/src/main/java/org/hippoecm/repository/OrderBy.java	(revision 57427)
+++ provider/src/main/java/org/hippoecm/repository/OrderBy.java	(revision )
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2010-2013 Hippo B.V. (http://www.onehippo.com)
+ *  Copyright 2010-2016 Hippo B.V. (http://www.onehippo.com)
  * 
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -19,21 +19,29 @@
 
     private String name;
     private boolean descending;
+    private String orderFunction;
 
     public OrderBy(String name) {
         this.name = name;
     }
 
-    public OrderBy(String name, boolean descending) {
-        this.name = name;
-        this.descending = descending;
-    }
-
     public String getName() {
         return name;
     }
 
     public boolean isDescending() {
         return descending;
+    }
+
+    public void setDescending(final boolean descending) {
+        this.descending = descending;
+    }
+
+    public void setOrderFunction(final String orderFunction) {
+        this.orderFunction = orderFunction;
+    }
+
+    public String getOrderFunction() {
+        return orderFunction;
     }
 }
Index: test/src/test/java/org/hippoecm/repository/facetnavigation/FacetedNavigationSimpleTest.java
IDEA additional info:
Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
<+>UTF-8
===================================================================
--- test/src/test/java/org/hippoecm/repository/facetnavigation/FacetedNavigationSimpleTest.java	(revision 57427)
+++ test/src/test/java/org/hippoecm/repository/facetnavigation/FacetedNavigationSimpleTest.java	(revision )
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2010-2013 Hippo B.V. (http://www.onehippo.com)
+ *  Copyright 2010-2016 Hippo B.V. (http://www.onehippo.com)
  * 
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -16,13 +16,16 @@
 package org.hippoecm.repository.facetnavigation;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Calendar;
+import java.util.List;
 
 import javax.jcr.Node;
 import javax.jcr.NodeIterator;
 import javax.jcr.RepositoryException;
 
-import org.apache.jackrabbit.commons.iterator.NodeIterable;
+import com.google.common.collect.ImmutableList;
+
 import org.hippoecm.repository.HippoStdNodeType;
 import org.hippoecm.repository.api.HippoNodeType;
 import org.hippoecm.repository.api.NodeNameCodec;
@@ -391,6 +394,194 @@
                 }
                 prevBrandValue = brand;
             }
+        }
+    }
+
+    @Test
+    public void testSortResultSetOnStringPropertyWithSortFunction() throws RepositoryException, IOException {
+        commonStart();
+        Node testNode = session.getRootNode().getNode("test");
+        createSimpleStructure1(testNode);
+        final Node cars = testNode.getNode("documents").getNode("cars");
+        {
+            // car 'grey' but now as 'Grey'
+            Node handle = cars.addNode("car25", "hippo:handle");
+            handle.addMixin("hippo:hardhandle");
+            final Node car = handle.addNode("car25", "hippo:testcardocument");
+            car.addMixin("mix:versionable");
+            car.setProperty("hippo:brand", "mercedes");
+            car.setProperty("hippo:color", "Grey");
+            car.setProperty("hippo:product", "car");
+            car.setProperty("hippo:date", globalCal);
+            car.setProperty("hippo:price", 12000.0D);
+            car.setProperty("hippo:travelled", 122000L);
+        }
+        {
+            // car 'blue' but now as 'Blue'
+            Node handle = cars.addNode("car26", "hippo:handle");
+            handle.addMixin("hippo:hardhandle");
+            final Node car = handle.addNode("car26", "hippo:testcardocument");
+            car.addMixin("mix:versionable");
+            car.setProperty("hippo:brand", "mercedes");
+            car.setProperty("hippo:color", "Blue");
+            car.setProperty("hippo:product", "car");
+            car.setProperty("hippo:date", globalCal);
+            car.setProperty("hippo:price", 12000.0D);
+            car.setProperty("hippo:travelled", 122000L);
+        }
+
+        createFacetNodeSingleValues(testNode);
+
+        Node navigation = session.getRootNode().getNode("test/facetnavigation/hippo:navigation");
+        navigation.setProperty(FacNavNodeType.HIPPOFACNAV_FACETSORTBY, new String[] { "hippo:color"});
+        navigation.setProperty(FacNavNodeType.HIPPOFACNAV_FACETSORTORDER, new String[] { "ascending"});
+        session.save();
+
+        {
+            // assert sorting FIRST without sort function: Then we expect case sensitive sorting since that is the default
+            final List<String> result = new ArrayList<>();
+            navigation = session.getRootNode().getNode("test/facetnavigation/hippo:navigation");
+            {
+                NodeIterator it = navigation.getNode("hippo:resultset").getNodes();
+                while (it.hasNext()) {
+                    Node n = it.nextNode();
+                    if (n.hasProperty("hippo:color")) {
+                        result.add(n.getProperty("hippo:color").getString());
+                    }
+                }
+            }
+            final List<String> expectation = ImmutableList.of("Blue", "Grey", "blue", "grey", "grey", "grey");
+            assertEquals(expectation, result);
+        }
+
+        // add sort function
+        navigation.setProperty(FacNavNodeType.HIPPOFACNAV_FACETSORTFUNCTION, new String[] { "lower-case"});
+        session.save();
+
+        {
+            // now case *insensitive sorting expected!
+            final List<String> result = new ArrayList<>();
+            navigation = session.getRootNode().getNode("test/facetnavigation/hippo:navigation");
+            {
+                NodeIterator it = navigation.getNode("hippo:resultset").getNodes();
+                while (it.hasNext()) {
+                    Node n = it.nextNode();
+                    if (n.hasProperty("hippo:color")) {
+                        // make sorted list also to lowercase to assure expected list equal
+                        result.add(n.getProperty("hippo:color").getString().toLowerCase());
+                    }
+                }
+            }
+            final List<String> expectation = ImmutableList.of("blue", "blue", "grey", "grey", "grey", "grey");
+            assertEquals(expectation, result);
+        }
+
+
+        {
+            // car 'grey' but now as 'GrĔy'
+            Node handle = cars.addNode("car27", "hippo:handle");
+            handle.addMixin("hippo:hardhandle");
+            final Node car = handle.addNode("car27", "hippo:testcardocument");
+            car.addMixin("mix:versionable");
+            car.setProperty("hippo:brand", "mercedes");
+            // '\u0114': // Ĕ  [LATIN CAPITAL LETTER E WITH BREVE]
+            car.setProperty("hippo:color", "Gr"+'\u0114'+"y");
+            car.setProperty("hippo:product", "car");
+            car.setProperty("hippo:date", globalCal);
+            car.setProperty("hippo:price", 12000.0D);
+            car.setProperty("hippo:travelled", 122000L);
+        }
+        {
+            // car 'blue' but now as 'BlỦe'
+            Node handle = cars.addNode("car28", "hippo:handle");
+            handle.addMixin("hippo:hardhandle");
+            final Node car = handle.addNode("car28", "hippo:testcardocument");
+            car.addMixin("mix:versionable");
+            car.setProperty("hippo:brand", "mercedes");
+            // '\u1EE6': // Ủ  [LATIN CAPITAL LETTER U WITH HOOK ABOVE]
+            car.setProperty("hippo:color", "Bl"+'\u1EE6'+"e");
+            car.setProperty("hippo:product", "car");
+            car.setProperty("hippo:date", globalCal);
+            car.setProperty("hippo:price", 12000.0D);
+            car.setProperty("hippo:travelled", 122000L);
+        }
+        {
+            // car 'blue' but now as 'Blue' just to make sure we have a car after BlỦe
+            Node handle = cars.addNode("car29", "hippo:handle");
+            handle.addMixin("hippo:hardhandle");
+            final Node car = handle.addNode("car29", "hippo:testcardocument");
+            car.addMixin("mix:versionable");
+            car.setProperty("hippo:brand", "mercedes");
+            // '\u1EE6': // Ủ  [LATIN CAPITAL LETTER U WITH HOOK ABOVE]
+            car.setProperty("hippo:color", "Blue");
+            car.setProperty("hippo:product", "car");
+            car.setProperty("hippo:date", globalCal);
+            car.setProperty("hippo:price", 12000.0D);
+            car.setProperty("hippo:travelled", 122000L);
+        }
+
+        {
+            // car Âlue  :
+            Node handle = cars.addNode("car30", "hippo:handle");
+            handle.addMixin("hippo:hardhandle");
+            final Node car = handle.addNode("car30", "hippo:testcardocument");
+            car.addMixin("mix:versionable");
+            car.setProperty("hippo:brand", "mercedes");
+            // '\u00C2': // Â  [LATIN CAPITAL LETTER A WITH CIRCUMFLEX]
+            car.setProperty("hippo:color", '\u00C2' + "lue");
+            car.setProperty("hippo:product", "car");
+            car.setProperty("hippo:date", globalCal);
+            car.setProperty("hippo:price", 12000.0D);
+            car.setProperty("hippo:travelled", 122000L);
+        }
+
+        session.save();
+
+        {
+            // now case *insensitive* sorting expected!
+            final List<String> result = new ArrayList<>();
+            navigation = session.getRootNode().getNode("test/facetnavigation/hippo:navigation");
+            {
+                NodeIterator it = navigation.getNode("hippo:resultset").getNodes();
+                while (it.hasNext()) {
+                    Node n = it.nextNode();
+                    if (n.hasProperty("hippo:color")) {
+                        // make sorted list also to lowercase to assure expected list equal
+                        result.add(n.getProperty("hippo:color").getString().toLowerCase());
+                    }
+                }
+            }
+
+            // '\u00E2': // â  [LATIN SMALL LETTER A WITH CIRCUMFLEX]
+            // '\u0115': // ĕ  [LATIN SMALL LETTER E WITH BREVE]
+            // '\u1EE7': // ủ  [LATIN SMALL LETTER U WITH HOOK ABOVE]
+            // only case insensitive sorting, hence we expect the ĕ and  ủ after 'e' and 'u' and that Âlue is last
+            final List<String> expectation = ImmutableList.of("blue", "blue", "blue","bl"+'\u1EE7'+"e", "grey", "grey", "grey", "grey", "gr"+'\u0115'+"y", '\u00E2' + "lue");
+            assertEquals(expectation, result);
+        }
+
+        // now sort with 'normalize' : Meaning case insensitive and regardless diacritics, see org.apache.jackrabbit.core.query.lucene.NormalizeSortComparator.NormalizeSortComparator()
+        // set sort function to 'normalize'
+        navigation.setProperty(FacNavNodeType.HIPPOFACNAV_FACETSORTFUNCTION, new String[] { "normalize"});
+        session.save();
+
+        {
+            // now case *normaized* () sorting expected!
+            final List<String> result = new ArrayList<>();
+            navigation = session.getRootNode().getNode("test/facetnavigation/hippo:navigation");
+            {
+                NodeIterator it = navigation.getNode("hippo:resultset").getNodes();
+                while (it.hasNext()) {
+                    Node n = it.nextNode();
+                    if (n.hasProperty("hippo:color")) {
+                        // make sorted list also to lowercase to assure expected list equal
+                        result.add(n.getProperty("hippo:color").getString().toLowerCase());
+                    }
+                }
+            }
+            // normalized sorting : We expect Âlue is first
+            final List<String> expectation = ImmutableList.of('\u00E2' + "lue", "blue", "blue", "bl"+'\u1EE7'+"e", "grey", "grey", "grey", "grey", "gr"+'\u0115'+"y");
+            assertEquals(expectation, result);
         }
     }
 
