diff --git a/oak-run/pom.xml b/oak-run/pom.xml
index 4eaac72..57ae297 100644
--- a/oak-run/pom.xml
+++ b/oak-run/pom.xml
@@ -293,6 +293,11 @@
       <version>2.4</version>
     </dependency>
     <dependency>
+      <groupId>commons-lang</groupId>
+      <artifactId>commons-lang</artifactId>
+      <version>2.3</version>
+    </dependency>
+    <dependency>
       <groupId>org.eclipse.jetty</groupId>
       <artifactId>jetty-servlet</artifactId>
       <version>${jetty.version}</version>
diff --git a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java
index 0292b65..4cff28a 100644
--- a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java
+++ b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/BenchmarkRunner.java
@@ -263,7 +263,9 @@ public class BenchmarkRunner {
             new FullTextSearchTest(
                     wikipedia.value(options),
                     flatStructure.value(options),
-                    report.value(options), withStorage.value(options))
+                    report.value(options), withStorage.value(options)),
+            new MultiLucenePropertyIndexSearchTest(),
+            new StandardPropertyIndexSearchTest(),
         };
 
         Set<String> argset = Sets.newHashSet(nonOption.values(options));
diff --git a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/MultiLucenePropertyIndexSearchTest.java b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/MultiLucenePropertyIndexSearchTest.java
new file mode 100644
index 0000000..30fe3c8
--- /dev/null
+++ b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/MultiLucenePropertyIndexSearchTest.java
@@ -0,0 +1,254 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.jackrabbit.oak.benchmark;
+
+import org.apache.commons.lang.RandomStringUtils;
+import org.apache.jackrabbit.JcrConstants;
+import org.apache.jackrabbit.oak.api.Type;
+import org.apache.jackrabbit.oak.fixture.JcrCustomizer;
+import org.apache.jackrabbit.oak.fixture.OakRepositoryFixture;
+import org.apache.jackrabbit.oak.fixture.RepositoryFixture;
+import org.apache.jackrabbit.oak.jcr.Jcr;
+import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants;
+import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexEditorProvider;
+import org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexProvider;
+import org.apache.jackrabbit.oak.plugins.memory.PropertyStates;
+import org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants;
+import org.apache.jackrabbit.oak.spi.commit.Observer;
+import org.apache.jackrabbit.oak.spi.lifecycle.RepositoryInitializer;
+import org.apache.jackrabbit.oak.spi.query.QueryIndexProvider;
+import org.apache.jackrabbit.oak.spi.state.NodeBuilder;
+
+import javax.annotation.Nonnull;
+import javax.jcr.Node;
+import javax.jcr.NodeIterator;
+import javax.jcr.Repository;
+import javax.jcr.RepositoryException;
+import javax.jcr.Session;
+import javax.jcr.query.Query;
+import javax.jcr.query.QueryManager;
+import javax.jcr.query.QueryResult;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import static com.google.common.collect.ImmutableSet.of;
+import static org.apache.jackrabbit.oak.plugins.index.IndexConstants.*;
+import static org.apache.jackrabbit.oak.plugins.index.lucene.LuceneIndexConstants.*;
+
+public class MultiLucenePropertyIndexSearchTest extends AbstractTest<MultiLucenePropertyIndexSearchTest.TestContext> {
+
+    private TestContext defaultContext;
+
+    Node index;
+
+    /**
+     * constant used to identify how many nodes will be fetched after the query execution
+     */
+    public static final int FETCH_NODES = 100;
+
+    static final int PRE_MATCHING_RESULTS = Integer.parseInt(System.getProperty("matchingResults", "0"));
+
+    /**
+     * number of nodes that has to be added before performing the actual test
+     */
+    static final int PRE_ADDED_NODES = Integer.parseInt(System.getProperty("preAddedNodes", "0"));
+
+    /**
+     * type of the created node
+     */
+    static final String NODE_TYPE = NodeTypeConstants.NT_OAK_UNSTRUCTURED;
+
+    /**
+     * property that will be indexed
+     */
+    static final String INDEXED_PROPERTY = "indexedProperty";
+
+    /**
+     * size of the batch for saving
+     */
+    static final int BATCH_SAVING_SIZE = Integer
+            .parseInt(System.getProperty("batchSaving", "1024"));
+
+    private static final int WORD_LENGTH = 16;
+
+    protected List<String> matchingWords;
+
+    /**
+     * flags whether batch saving or not. Provide {@code -DbatchSaving=XYZ} where {@code XYZ} is
+     * greater than 0 to enable batch saving otherwise it will save every added nodes.
+     */
+    static final boolean BATCH_SAVING = BATCH_SAVING_SIZE > 0;
+
+    /**
+     * node name below which creating the test data
+     */
+    final String DUMP_NODE = this.getClass().getSimpleName() + TEST_ID;
+
+    /**
+     * node under which all the test data will be filled in
+     */
+    Node dump;
+
+    /**
+     * query to execute WITHOUT the ORDER BY clause
+     */
+    static final String QUERY_WITH_PROPERTY_EQUALITY = String.format(
+            "SELECT * FROM [%s] WHERE %s = ", NODE_TYPE, INDEXED_PROPERTY);
+
+    /**
+     * query to execute WITHOUT the ORDER BY clause
+     */
+    static final String QUERY_WITH_PROPERTY_LIKE = String.format(
+            "SELECT * FROM [%s] WHERE %s like ", NODE_TYPE, INDEXED_PROPERTY);
+
+    static final String persistencePath = System.getProperty("persistencePath", null);
+
+
+    void insertNodes(int numOfNodes, int numOfMatchingResults) {
+        if (numOfMatchingResults <= 0) {
+            numOfMatchingResults = numOfNodes;
+        }
+        try {
+            matchingWords = new ArrayList<String>();
+            String word = "";
+            for (int i = 0, count = 0; i < numOfNodes; i++) {
+                if (i % numOfMatchingResults == 0) {
+                    word = RandomStringUtils.randomAlphanumeric(WORD_LENGTH);
+                    matchingWords.add(word);
+                    count = 0;
+                } else {
+                    count++;
+                }
+                dump.addNode(word + count, NODE_TYPE).setProperty(INDEXED_PROPERTY, word);
+                if (isBatchSaving()) {
+                    if (i % BATCH_SAVING_SIZE == 0) {
+                        defaultContext.session.save();
+                    }
+                } else {
+                    defaultContext.session.save();
+                }
+            }
+            if (isBatchSaving()) {
+                // an extra save to catch any pending operations.
+                defaultContext.session.save();
+            }
+        } catch (RepositoryException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public MultiLucenePropertyIndexSearchTest() {
+    }
+
+    @Override
+    public void beforeSuite() throws Exception {
+        defaultContext = new TestContext();
+        dump = defaultContext.session.getRootNode().addNode(DUMP_NODE, NODE_TYPE);
+        defaultContext.session.save();
+        insertNodes(PRE_ADDED_NODES, PRE_MATCHING_RESULTS);
+        defaultContext.session.save();
+    }
+
+    @Override
+    protected void runTest() throws Exception {
+        QueryManager qm = defaultContext.session.getWorkspace().getQueryManager();
+        Query q = qm.createQuery(getQuery(), Query.JCR_SQL2);
+        QueryResult r = q.execute();
+        NodeIterator nodes = r.getNodes();
+        int counter = 0;
+        while(nodes.hasNext() && counter++<FETCH_NODES) {
+            nodes.next();
+        }
+    }
+
+    @Override
+    protected void afterSuite() throws Exception {
+        dump.remove();
+        if(index!=null) {
+            index.remove();
+        }
+        defaultContext.session.save();
+        defaultContext.session.logout();
+    }
+
+    @Override
+    protected TestContext prepareThreadExecutionContext() {
+        return new TestContext();
+    }
+
+    class TestContext {
+        final Session session = loginWriter();
+        int hash = 0; // summary variable to prevent JIT compiler tricks
+    }
+
+    @Override
+    protected Repository[] createRepository(RepositoryFixture fixture) throws Exception {
+        if (fixture instanceof OakRepositoryFixture) {
+            return ((OakRepositoryFixture) fixture).setUpCluster(1, new JcrCustomizer() {
+                @Override
+                public Jcr customize(Jcr jcr) {
+                    LuceneIndexProvider provider = new LuceneIndexProvider();
+
+                    jcr.with((QueryIndexProvider) provider)
+                       .with((Observer) provider)
+                       .with(new LuceneIndexEditorProvider())
+                       .with(new RepositoryInitializer() {
+                           @Override
+                           public void initialize(@Nonnull NodeBuilder builder) {
+                               builder = builder.child(INDEX_DEFINITIONS_NAME);
+                               if(!builder.hasChildNode(INDEXED_PROPERTY)) {
+                                   builder = builder.child(INDEXED_PROPERTY);
+                                   builder.setProperty(JcrConstants.JCR_PRIMARYTYPE,
+                                           INDEX_DEFINITIONS_NODE_TYPE, Type.NAME)
+                                        .setProperty(TYPE_PROPERTY_NAME, LuceneIndexConstants.TYPE_LUCENE)
+                                        .setProperty(REINDEX_PROPERTY_NAME, true)
+                                        .setProperty(LuceneIndexConstants.FULL_TEXT_ENABLED, false)
+                                        .setProperty(PropertyStates.createProperty(LuceneIndexConstants.INCLUDE_PROPERTY_NAMES,
+                                                of(INDEXED_PROPERTY), Type.STRINGS));
+                                   if (persistencePath != null) {
+                                       builder.setProperty(PERSISTENCE_PATH, persistencePath)
+                                               .setProperty(PERSISTENCE_NAME, PERSISTENCE_FILE);
+
+                                   }
+                               }
+                           }
+                       });
+                    return jcr;
+                }
+            });
+        }
+        return super.createRepository(fixture);
+    }
+
+    /**
+     *
+     * @return true if you want batch saving during {@code insertRandomNodes} by
+     *         {@code BATCH_SAVE_SIZE}
+     */
+    boolean isBatchSaving() {
+        return BATCH_SAVING;
+    }
+
+    String getQuery() {
+        String word = matchingWords.get(new Random().nextInt(matchingWords.size()));
+        return QUERY_WITH_PROPERTY_EQUALITY + "'" + word+ "'";
+    }
+
+}
diff --git a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexBaseTest.java b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexBaseTest.java
index 79ffdc1..ae0fc7f 100644
--- a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexBaseTest.java
+++ b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexBaseTest.java
@@ -17,12 +17,15 @@
 
 package org.apache.jackrabbit.oak.benchmark;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.UUID;
 
 import javax.jcr.Node;
 import javax.jcr.RepositoryException;
 import javax.jcr.Session;
 
+import org.apache.commons.lang.RandomStringUtils;
 import org.apache.jackrabbit.oak.benchmark.util.OakIndexUtils;
 import org.apache.jackrabbit.oak.plugins.index.IndexConstants;
 import org.apache.jackrabbit.oak.plugins.index.property.OrderedIndex;
@@ -60,6 +63,10 @@ public abstract class OrderedIndexBaseTest extends AbstractTest {
      */
     static final int BATCH_SAVING_SIZE = Integer
         .parseInt(System.getProperty("batchSaving", "1024"));
+
+    private static final int WORD_LENGTH = 16;
+
+    protected List<String> matchingWords;
     
     /**
      * flags whether batch saving or not. Provide {@code -DbatchSaving=XYZ} where {@code XYZ} is
@@ -109,6 +116,36 @@ public abstract class OrderedIndexBaseTest extends AbstractTest {
         }
     }
 
+    void insertNodes(int numOfNodes, int numOfMatchingResults) {
+        if (numOfMatchingResults <= 0) {
+            numOfMatchingResults = numOfNodes;
+        }
+        try {
+            matchingWords = new ArrayList<String>();
+            String word = "";
+            for (int i = 0; i < numOfNodes; i++) {
+                if (i % numOfMatchingResults == 0) {
+                    word = RandomStringUtils.randomAlphanumeric(WORD_LENGTH);
+                    matchingWords.add(word);
+                }
+                dump.addNode(word + i, NODE_TYPE).setProperty(INDEXED_PROPERTY, word);
+                if (isBatchSaving()) {
+                    if (i % BATCH_SAVING_SIZE == 0) {
+                        session.save();
+                    }
+                } else {
+                    session.save();
+                }
+            }
+            if (isBatchSaving()) {
+                // an extra save to catch any pending operations.
+                session.save();
+            }
+        } catch (RepositoryException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     /**
      * override when needed to define an index
      */
diff --git a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexQueryBaseTest.java b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexQueryBaseTest.java
index df04ef8..f2c64ce 100644
--- a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexQueryBaseTest.java
+++ b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/OrderedIndexQueryBaseTest.java
@@ -45,6 +45,12 @@ public abstract class OrderedIndexQueryBaseTest extends OrderedIndexBaseTest {
     public static final String QUERY_WITHOUT_ORDER = String.format(
         "SELECT * FROM [%s] WHERE %s IS NOT NULL", NODE_TYPE, INDEXED_PROPERTY);
 
+    static final String QUERY_WITH_PROPERTY_EQUALITY = String.format(
+            "SELECT * FROM [%s] WHERE %s = ", NODE_TYPE, INDEXED_PROPERTY);
+
+    static final String QUERY_WITH_PROPERTY_LIKE = String.format(
+            "SELECT * FROM [%s] WHERE %s like ", NODE_TYPE, INDEXED_PROPERTY);
+
     @Override
     protected void beforeSuite() throws Exception {
         session = loginWriter();
diff --git a/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/StandardPropertyIndexSearchTest.java b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/StandardPropertyIndexSearchTest.java
new file mode 100644
index 0000000..41a35fc
--- /dev/null
+++ b/oak-run/src/main/java/org/apache/jackrabbit/oak/benchmark/StandardPropertyIndexSearchTest.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.jackrabbit.oak.benchmark;
+
+
+import java.util.Random;
+
+/**
+ * Benchmark the query performance of an ORDER BY clause when No index are involved
+ */
+public class StandardPropertyIndexSearchTest extends OrderedIndexQueryBaseTest {
+
+    static final int PRE_MATCHING_RESULTS = Integer.parseInt(System.getProperty("matchingResults", "0"));
+
+    @Override
+    protected void beforeSuite() throws Exception {
+        session = loginWriter();
+        dump = session.getRootNode().addNode(DUMP_NODE, NODE_TYPE);
+        session.save();
+        defineIndex();
+        insertNodes(PRE_ADDED_NODES, PRE_MATCHING_RESULTS);
+    }
+
+    @Override
+    protected void afterSuite() throws Exception {
+        dump.remove();
+        if(index!=null) {
+            index.remove();
+        }
+        session.save();
+        session.logout();
+    }
+
+    @Override
+    void defineIndex() throws Exception {
+        index = defineStandardPropertyIndex(session);
+    }
+
+    @Override
+    String getQuery() {
+        String word = matchingWords.get(new Random().nextInt(matchingWords.size()));
+        return QUERY_WITH_PROPERTY_EQUALITY + "'" + word + "'";
+    }
+
+}