Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.mk.test;
 
 import java.util.Map;
 import java.util.Set;
 
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;

Abstract base class for org.apache.jackrabbit.mk.api.MicroKernel integration tests.
 
 public abstract class AbstractMicroKernelIT {

    
Finds and returns all MicroKernelFixture services available in the current classpath.

Returns:
available MicroKernelFixture services
 
     @Parameters
     public static Collection<Object[]> loadFixtures() {
         Collection<Object[]> fixtures = new ArrayList<Object[]>();
 
         Class<MicroKernelFixtureiface = MicroKernelFixture.class;
         ServiceLoader<MicroKernelFixtureloader =
                 ServiceLoader.load(ifaceiface.getClassLoader());
         for (MicroKernelFixture fixture : loader) {
             if (fixture.isAvailable()) {
                 fixtures.add(new Object[] { fixture });
             }
         }
 
         return fixtures;
     }

    
The MicroKernelFixture service used by this test case instance.
 
     protected final MicroKernelFixture fixture;

    
The org.apache.jackrabbit.mk.api.MicroKernel cluster node instances used by this test case.
 
     protected final MicroKernel[] mks;

    
The org.apache.jackrabbit.mk.api.MicroKernel instance used by this test case. In a clustered setup this is the first node of the cluster.
 
     protected MicroKernel mk;

    
A JSON parser instance that can be used for parsing JSON-format data; JSONParser instances are not not thread-safe.

See also:
getJSONParser()
 
     private JSONParser parser;

    
Creates a org.apache.jackrabbit.mk.api.MicroKernel test case for a cluster of the given size created using the given MicroKernelFixture service.

Parameters:
fixture MicroKernelFixture service
nodeCount number of nodes that the test cluster should contain
 
     protected AbstractMicroKernelIT(MicroKernelFixture fixtureint nodeCount) {
        checkArgument(nodeCount > 0);
        this. = fixture;
        this. = new MicroKernel[nodeCount];
    }

    
Prepares the test case by initializing the mks and mk variables with a new org.apache.jackrabbit.mk.api.MicroKernel cluster from the MicroKernelFixture service associated with this test case.
    @Before
    public void setUp() throws Exception {
        .setUpCluster();
         = [0];
        addInitialTestContent();
    }

    
Adds initial content used by the test case. This method is called by the setUp() method after the org.apache.jackrabbit.mk.api.MicroKernel cluster has been set up and before the actual test is run. The default implementation does nothing, but subclasses can override this method to perform extra initialization.
    protected void addInitialTestContent() {
    }

    
Releases the org.apache.jackrabbit.mk.api.MicroKernel cluster used by this test case.
    @After
    public void tearDown() {
        .tearDownCluster();
        // Clear fields to avoid consuming memory after the test has run.
        // It looks like JUnit keeps references to all test instances until
        // the entire test suite has been run.
        Arrays.fill(null);
         = null;
         = null;
    }
    //--------------------------------< utility methods for parsing json data >
    
Returns a JSONParser instance for parsing JSON format data. This method returns a cached instance.

JSONParser instances are not thread-safe. Multi-threaded unit tests should therefore override this method and return a fresh instance on every invocation.

Returns:
a JSONParser instance
    protected synchronized JSONParser getJSONParser() {
        if ( == null) {
             = new JSONParser();
        }
        return ;
    }

    
Parses the provided string into a JSONObject.

Parameters:
json string to be parsed
Returns:
a JSONObject
Throws:
AssertionError if the string cannot be parsed into a JSONObject
    protected JSONObject parseJSONObject(String jsonthrows AssertionError {
        JSONParser parser = getJSONParser();
        try {
            Object obj = parser.parse(json);
            assertTrue(obj instanceof JSONObject);
            return (JSONObjectobj;
        } catch (Exception e) {
            throw new AssertionError("not a valid JSON object: " + e.getMessage());
        }
    }

    
Parses the provided string into a JSONArray.

Parameters:
json string to be parsed
Returns:
a JSONArray
Throws:
AssertionError if the string cannot be parsed into a JSONArray
    protected JSONArray parseJSONArray(String jsonthrows AssertionError {
        JSONParser parser = getJSONParser();
        try {
            Object obj = parser.parse(json);
            assertTrue(obj instanceof JSONArray);
            return (JSONArrayobj;
        } catch (Exception e) {
            throw new AssertionError("not a valid JSON array: " + e.getMessage());
        }
    }
    protected Set<StringgetNodeNames(JSONObject obj) {
        Set<Stringnames = new HashSet<String>();
        Set<Map.Entryentries = obj.entrySet();
        for (Map.Entry entry : entries) {
            if (entry.getValue() instanceof JSONObject) {
                names.add((Stringentry.getKey());
            }
        }
        return names;
    }
    protected Set<StringgetPropertyNames(JSONObject obj) {
        Set<Stringnames = new HashSet<String>();
        Set<Map.Entryentries = obj.entrySet();
        for (Map.Entry entry : entries) {
            if (! (entry.getValue() instanceof JSONObject)) {
                names.add((Stringentry.getKey());
            }
        }
        return names;
    }
    protected void assertPropertyExists(JSONObject objString relPath)
            throws AssertionError {
        Object val = resolveValue(objrelPath);
        assertNotNull("not found: " + relPathval);
    }
    protected void assertPropertyNotExists(JSONObject objString relPath)
            throws AssertionError {
        Object val = resolveValue(objrelPath);
        assertNull(val);
    }
    protected void assertPropertyExists(JSONObject objString relPathClass type)
            throws AssertionError {
        Object val = resolveValue(objrelPath);
        assertNotNull("not found: " + relPathval);
        assertTrue(type.isInstance(val));
    }
    protected void assertPropertyValue(JSONObject objString relPathDouble expected)
            throws AssertionError {
        Object val = resolveValue(objrelPath);
        assertNotNull("not found: " + relPathval);
        assertEquals(expectedval);
    }
    protected void assertPropertyValue(JSONObject objString relPathLong expected)
            throws AssertionError {
        Object val = resolveValue(objrelPath);
        assertNotNull("not found: " + relPathval);
        assertEquals(expectedval);
    }
    protected void assertPropertyValue(JSONObject objString relPathBoolean expected)
            throws AssertionError {
        Object val = resolveValue(objrelPath);
        assertNotNull("not found: " + relPathval);
        assertEquals(expectedval);
    }
    protected void assertPropertyValue(JSONObject objString relPathString expected)
            throws AssertionError {
        Object val = resolveValue(objrelPath);
        assertNotNull("not found: " + relPathval);
        assertEquals(expectedval);
    }
    protected void assertPropertyValue(JSONObject objString relPathObject[] expected)
            throws AssertionError {
        JSONArray array = resolveArrayValue(objrelPath);
        assertNotNull("not found: " + relPatharray);
        assertEquals(expected.lengtharray.size());
        // JSON numeric types: Double, Long
        // convert types as necessary for comparison using equals method
        for (int i = 0; i < array.size(); i++) {
            Object o1 = expected[i];
            Object o2 = array.get(i);
            if (o1 instanceof Number && o2 instanceof Number) {
                if (o1 instanceof Integer) {
                    o1 = new Long((Integero1);
                } else if (o1 instanceof Short) {
                    o1 = new Long((Shorto1);
                } else if (o1 instanceof Float) {
                    o1 = new Double((Floato1);
                }
            }
            assertEquals(o1o2);
        }
    }
    protected JSONObject resolveObjectValue(JSONObject objString relPath) {
        Object val = resolveValue(objrelPath);
        if (val instanceof JSONObject) {
            return (JSONObjectval;
        }
        throw new AssertionError("failed to resolve JSONObject value at " + relPath + ": " + val);
    }
    protected JSONObject getObjectArrayEntry(JSONArray arrayint pos) {
        assertTrue(pos >= 0 && pos < array.size());
        Object entry = array.get(pos);
        if (entry instanceof JSONObject) {
            return (JSONObjectentry;
        }
        throw new AssertionError("failed to resolve JSONObject array entry at pos " + pos + ": " + entry);
    }
    protected JSONArray resolveArrayValue(JSONObject objString relPath) {
        Object val = resolveValue(objrelPath);
        if (val instanceof JSONArray) {
            return (JSONArrayval;
        }
        throw new AssertionError("failed to resolve JSONArray value at " + relPath + ": " + val);
    }
    protected Object resolveValue(JSONObject objString relPath) {
        String names[] = relPath.split("/");
        Object val = obj;
        for (String name : names) {
            if (! (val instanceof JSONObject)) {
                throw new AssertionError("not found: " + relPath);
            }
            val = ((JSONObjectval).get(name);
        }
        return val;
    }
    protected void assertPropExists(String revString pathString property) {
        String nodes = .getNodes(pathrev, -1 /*depth*/, 0 /*offset*/, -1 /*maxChildNodes*/null /*filter*/);
        JSONObject obj = parseJSONObject(nodes);
        assertPropertyExists(objproperty);
    }
    protected void assertPropNotExists(String revString pathString property) {
        String nodes = .getNodes(pathrev, -1 /*depth*/, 0 /*offset*/, -1 /*maxChildNodes*/null /*filter*/);
        if (nodes == null) {
            return;
        }
        JSONObject obj = parseJSONObject(nodes);
        assertPropertyNotExists(objproperty);
    }
    protected void assertPropValue(String revString pathString propertyString value) {
        String nodes = .getNodes(pathrev, -1 /*depth*/, 0 /*offset*/, -1 /*maxChildNodes*/null /*filter*/);
        JSONObject obj = parseJSONObject(nodes);
        assertPropertyValue(objpropertyvalue);
    }
    protected String addNodes(String revString...nodes) {
        String newRev = rev;
        for (String node : nodes) {
            newRev = .commit("""+\"" + node + "\":{}"newRev"");
        }
        return newRev;
    }
    protected String removeNodes(String revString...nodes) {
        String newRev = rev;
        for (String node : nodes) {
            newRev = .commit("""-\"" + node + "\""newRev"");
        }
        return newRev;
    }
    protected String setProp(String revString propObject value) {
        value = value == nullnull : "\"" + value + "\"";
        return .commit("""^\"" + prop + "\" : " + valuerev"");
    }
    protected void assertNodesExist(String revisionString...paths) {
        doAssertNodes(truerevisionpaths);
    }
    protected void assertNodesNotExist(String revisionString...paths) {
        doAssertNodes(falserevisionpaths);
    }
    protected void doAssertNodes(boolean checkExistsString revisionString...paths) {
        for (String path : paths) {
            boolean exists = .nodeExists(pathrevision);
            if (checkExists) {
                assertTrue(path + " does not exist"exists);
            } else {
                assertFalse(path + " should not exist"exists);
            }
        }
    }
New to GrepCode? Check out our FAQ X