ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [40/53] [abbrv] incubator-ignite git commit: # ignite-63
Date Fri, 23 Jan 2015 05:02:05 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
new file mode 100644
index 0000000..e14f966
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
@@ -0,0 +1,1434 @@
+/*
+ * 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.ignite.testframework.junits;
+
+import junit.framework.*;
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.events.*;
+import org.apache.ignite.internal.*;
+import org.apache.ignite.internal.util.*;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.marshaller.*;
+import org.apache.ignite.marshaller.jdk.*;
+import org.apache.ignite.marshaller.optimized.*;
+import org.apache.log4j.*;
+import org.apache.ignite.internal.processors.license.*;
+import org.apache.ignite.internal.processors.resource.*;
+import org.apache.ignite.spi.checkpoint.sharedfs.*;
+import org.apache.ignite.spi.communication.tcp.*;
+import org.apache.ignite.spi.discovery.tcp.*;
+import org.apache.ignite.spi.discovery.tcp.ipfinder.multicast.*;
+import org.apache.ignite.internal.util.typedef.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.testframework.*;
+import org.apache.ignite.testframework.config.*;
+import org.jetbrains.annotations.*;
+import org.springframework.beans.*;
+import org.springframework.context.*;
+import org.springframework.context.support.*;
+
+import java.lang.reflect.*;
+import java.net.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+import static org.apache.ignite.cache.GridCacheAtomicWriteOrderMode.*;
+import static org.apache.ignite.cache.GridCacheAtomicityMode.*;
+import static org.apache.ignite.cache.GridCacheDistributionMode.*;
+import static org.apache.ignite.cache.GridCacheWriteSynchronizationMode.*;
+
+/**
+ * Common abstract test for GridGain tests.
+ */
+@SuppressWarnings({
+    "TransientFieldInNonSerializableClass",
+    "ProhibitedExceptionDeclared",
+    "JUnitTestCaseWithNonTrivialConstructors"
+})
+public abstract class GridAbstractTest extends TestCase {
+    /**************************************************************
+     * DO NOT REMOVE TRANSIENT - THIS OBJECT MIGHT BE TRANSFERRED *
+     *                  TO ANOTHER NODE.                          *
+     **************************************************************/
+    /** Null name for execution map. */
+    private static final String NULL_NAME = UUID.randomUUID().toString();
+
+    /** */
+    private static final long DFLT_TEST_TIMEOUT = 5 * 60 * 1000;
+
+    /** */
+    private static final transient Map<Class<?>, TestCounters> tests = new ConcurrentHashMap<>();
+
+    /** */
+    private transient boolean startGrid;
+
+    /** */
+    protected transient IgniteLogger log;
+
+    /** */
+    private transient ClassLoader clsLdr;
+
+    /** */
+    private transient boolean stopGridErr;
+
+    /** Timestamp for tests. */
+    private static long ts = System.currentTimeMillis();
+
+    static {
+        System.setProperty(IgniteSystemProperties.GG_ATOMIC_CACHE_DELETE_HISTORY_SIZE, "10000");
+
+        Thread timer = new Thread(new GridTestClockTimer(), "gridgain-clock-for-tests");
+
+        timer.setDaemon(true);
+
+        timer.setPriority(10);
+
+        timer.start();
+    }
+
+    /** */
+    protected GridAbstractTest() {
+        this(false);
+
+        log = getTestCounters().getTestResources().getLogger().getLogger(getClass());
+    }
+
+    /**
+     * @param startGrid Start grid flag.
+     */
+    @SuppressWarnings({"OverriddenMethodCallDuringObjectConstruction"})
+    protected GridAbstractTest(boolean startGrid) {
+        assert isJunitFrameworkClass() : "GridAbstractTest class cannot be extended directly " +
+            "(use GridCommonAbstractTest class instead).";
+
+        // Initialize properties. Logger initialized here.
+        GridTestProperties.init();
+
+        log = getTestCounters().getTestResources().getLogger().getLogger(getClass());
+
+        this.startGrid = startGrid;
+    }
+
+    /**
+     * @param cls Class to create.
+     * @return Instance of class.
+     * @throws Exception If failed.
+     */
+    protected <T> T allocateInstance(Class<T> cls) throws Exception {
+        return (T)GridUnsafe.unsafe().allocateInstance(cls);
+    }
+
+    /**
+     * @param cls Class to create.
+     * @return Instance of class.
+     */
+    @Nullable protected <T> T allocateInstance0(Class<T> cls) {
+        try {
+            return (T)GridUnsafe.unsafe().allocateInstance(cls);
+        }
+        catch (InstantiationException e) {
+            e.printStackTrace();
+
+            return null;
+        }
+    }
+
+    /**
+     * @return Flag to check if class is Junit framework class.
+     */
+    protected boolean isJunitFrameworkClass() {
+        return false;
+    }
+
+    /**
+     * @return Test resources.
+     */
+    protected GridTestResources getTestResources() {
+        return getTestCounters().getTestResources();
+    }
+
+    /**
+     * @param msg Message to print.
+     */
+    protected void info(String msg) {
+        if (log().isInfoEnabled())
+            log().info(msg);
+    }
+
+    /**
+     * @param msg Message to print.
+     */
+    protected void error(String msg) {
+        log().error(msg);
+    }
+
+    /**
+     * @param msg Message to print.
+     * @param t Error to print.
+     */
+    protected void error(String msg, Throwable t) {
+        log().error(msg, t);
+    }
+
+    /**
+     * @return logger.
+     */
+    protected IgniteLogger log() {
+        return log;
+    }
+
+    /**
+     * Resets log4j programmatically.
+     *
+     * @param log4jLevel Level.
+     * @param logToFile If {@code true}, then log to file under "work/log" folder.
+     * @param cat Category.
+     * @param cats Additional categories.
+     */
+    @SuppressWarnings({"deprecation"})
+    protected void resetLog4j(Level log4jLevel, boolean logToFile, String cat, String... cats) {
+        for (String c : F.concat(false, cat, F.asList(cats)))
+            Logger.getLogger(c).setLevel(log4jLevel);
+
+        if (logToFile) {
+            Logger log4j = Logger.getRootLogger();
+
+            log4j.removeAllAppenders();
+
+            // Console appender.
+            ConsoleAppender c = new ConsoleAppender();
+
+            c.setName("CONSOLE_ERR");
+            c.setTarget("System.err");
+            c.setThreshold(Priority.WARN);
+            c.setLayout(new PatternLayout("[%d{ABSOLUTE}][%-5p][%t][%c{1}] %m%n"));
+
+            c.activateOptions();
+
+            log4j.addAppender(c);
+
+            // File appender.
+            RollingFileAppender file = new RollingFileAppender();
+
+            file.setName("FILE");
+            file.setThreshold(log4jLevel);
+            file.setFile(home() + "/work/log/gridgain.log");
+            file.setAppend(false);
+            file.setMaxFileSize("10MB");
+            file.setMaxBackupIndex(10);
+            file.setLayout(new PatternLayout("[%d{ABSOLUTE}][%-5p][%t][%c{1}] %m%n"));
+
+            file.activateOptions();
+
+            log4j.addAppender(file);
+        }
+    }
+
+    /**
+     * Executes runnable and prints out how long it took.
+     *
+     * @param name Name of execution.
+     * @param r Runnable to execute.
+     */
+    protected void time(String name, Runnable r) {
+        System.gc();
+
+        long start = System.currentTimeMillis();
+
+        r.run();
+
+        long dur = System.currentTimeMillis() - start;
+
+        info(name + " took " + dur + "ms.");
+    }
+
+    /**
+     * Runs given code in multiple threads and synchronously waits for all threads to complete.
+     * If any thread failed, exception will be thrown out of this method.
+     *
+     * @param r Runnable.
+     * @param threadNum Thread number.
+     * @throws Exception If failed.
+     */
+    protected void multithreaded(Runnable r, int threadNum) throws Exception {
+        multithreaded(r, threadNum, getTestGridName());
+    }
+
+    /**
+     * Runs given code in multiple threads and synchronously waits for all
+     * threads to complete. If any thread failed, exception will be thrown
+     * out of this method.
+     *
+     * @param r Runnable.
+     * @param threadNum Thread number.
+     * @param threadName Thread name.
+     * @throws Exception If failed.
+     */
+    protected void multithreaded(Runnable r, int threadNum, String threadName) throws Exception {
+        GridTestUtils.runMultiThreaded(r, threadNum, threadName);
+    }
+
+    /**
+     * Runs given code in multiple threads. Returns future that ends upon
+     * threads completion. If any thread failed, exception will be thrown
+     * out of this method.
+     *
+     * @param r Runnable.
+     * @param threadNum Thread number.
+     * @throws Exception If failed.
+     * @return Future.
+     */
+    protected IgniteFuture<?> multithreadedAsync(Runnable r, int threadNum) throws Exception {
+        return multithreadedAsync(r, threadNum, getTestGridName());
+    }
+
+    /**
+     * Runs given code in multiple threads. Returns future that ends upon
+     * threads completion. If any thread failed, exception will be thrown
+     * out of this method.
+     *
+     * @param r Runnable.
+     * @param threadNum Thread number.
+     * @param threadName Thread name.
+     * @throws Exception If failed.
+     * @return Future.
+     */
+    protected IgniteFuture<?> multithreadedAsync(Runnable r, int threadNum, String threadName) throws Exception {
+        return GridTestUtils.runMultiThreadedAsync(r, threadNum, threadName);
+    }
+
+    /**
+     * Runs given code in multiple threads and synchronously waits for all threads to complete.
+     * If any thread failed, exception will be thrown out of this method.
+     *
+     * @param c Callable.
+     * @param threadNum Thread number.
+     * @throws Exception If failed.
+     */
+    protected void multithreaded(Callable<?> c, int threadNum) throws Exception {
+        multithreaded(c, threadNum, getTestGridName());
+    }
+
+    /**
+     * Runs given code in multiple threads and synchronously waits for all threads to complete.
+     * If any thread failed, exception will be thrown out of this method.
+     *
+     * @param c Callable.
+     * @param threadNum Thread number.
+     * @param threadName Thread name.
+     * @throws Exception If failed.
+     */
+    protected void multithreaded(Callable<?> c, int threadNum, String threadName) throws Exception {
+        GridTestUtils.runMultiThreaded(c, threadNum, threadName);
+    }
+
+    /**
+     * Runs given code in multiple threads and asynchronously waits for all threads to complete.
+     * If any thread failed, exception will be thrown out of this method.
+     *
+     * @param c Callable.
+     * @param threadNum Thread number.
+     * @throws Exception If failed.
+     * @return Future.
+     */
+    protected IgniteFuture<?> multithreadedAsync(Callable<?> c, int threadNum) throws Exception {
+        return multithreadedAsync(c, threadNum, getTestGridName());
+    }
+
+    /**
+     * Runs given code in multiple threads and asynchronously waits for all threads to complete.
+     * If any thread failed, exception will be thrown out of this method.
+     *
+     * @param c Callable.
+     * @param threadNum Thread number.
+     * @param threadName Thread name.
+     * @throws Exception If failed.
+     * @return Future.
+     */
+    protected IgniteFuture<?> multithreadedAsync(Callable<?> c, int threadNum, String threadName) throws Exception {
+        return GridTestUtils.runMultiThreadedAsync(c, threadNum, threadName);
+    }
+
+    /**
+     * @return Test kernal context.
+     */
+    protected GridTestKernalContext newContext() {
+        GridTestKernalContext ctx = new GridTestKernalContext();
+
+        ctx.config().setGridLogger(log());
+
+        return ctx;
+    }
+
+    /**
+     * Called before execution of every test method in class.
+     *
+     * @throws Exception If failed. {@link #afterTest()} will be called in this case.
+     */
+    protected void beforeTest() throws Exception {
+        // No-op.
+    }
+
+    /**
+     * Called after execution of every test method in class or
+     * if {@link #beforeTest()} failed without test method execution.
+     *
+     * @throws Exception If failed.
+     */
+    protected void afterTest() throws Exception {
+        // No-op.
+    }
+
+    /**
+     * Called before execution of all test methods in class.
+     *
+     * @throws Exception If failed. {@link #afterTestsStopped()} will be called in this case.
+     */
+    protected void beforeTestsStarted() throws Exception {
+        // No-op.
+    }
+
+    /**
+     * Called after execution of all test methods in class or
+     * if {@link #beforeTestsStarted()} failed without execution of any test methods.
+     *
+     * @throws Exception If failed.
+     */
+    protected void afterTestsStopped() throws Exception {
+        // No-op.
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void setUp() throws Exception {
+        stopGridErr = false;
+
+        clsLdr = Thread.currentThread().getContextClassLoader();
+
+        // Change it to the class one.
+        Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+
+        // Clear log throttle.
+        LT.clear();
+
+        // Clear license registry.
+        GridLicenseUseRegistry.clear();
+
+        TestCounters cntrs = getTestCounters();
+
+        if (isDebug())
+            info("Test counters [numOfTests=" + cntrs.getNumberOfTests() + ", started=" + cntrs.getStarted() +
+                ", stopped=" + cntrs.getStopped() + ']');
+
+        if (cntrs.isReset()) {
+            info("Resetting test counters.");
+
+            int started = cntrs.getStarted() % cntrs.getNumberOfTests();
+            int stopped = cntrs.getStopped() % cntrs.getNumberOfTests();
+
+            cntrs.reset();
+
+            cntrs.setStarted(started);
+            cntrs.setStopped(stopped);
+        }
+
+        if (isFirstTest()) {
+            info(">>> Starting test class: " + getClass().getSimpleName() + " <<<");
+
+            if (startGrid) {
+                IgniteConfiguration cfg = optimize(getConfiguration());
+
+                G.start(cfg);
+            }
+
+            try {
+                beforeTestsStarted();
+            }
+            catch (Exception | Error t) {
+                t.printStackTrace();
+
+                getTestCounters().setStopped(getTestCounters().getNumberOfTests() - 1);
+
+                try {
+                    tearDown();
+                }
+                catch (Exception e) {
+                    log.error("Failed to tear down test after exception was thrown in beforeTestsStarted (will " +
+                        "ignore)", e);
+                }
+
+                throw t;
+            }
+        }
+
+        info(">>> Starting test: " + getName() + " <<<");
+
+        try {
+            beforeTest();
+        }
+        catch (Exception | Error t) {
+            try {
+                tearDown();
+            }
+            catch (Exception e) {
+                log.error("Failed to tear down test after exception was thrown in beforeTest (will ignore)", e);
+            }
+
+            throw t;
+        }
+
+        ts = System.currentTimeMillis();
+    }
+
+    /**
+     * @return Started grid.
+     * @throws Exception If anything failed.
+     */
+    protected Ignite startGrid() throws Exception {
+        return startGrid(getTestGridName());
+    }
+
+    /**
+     * @param cnt Grid count.
+     * @return First started grid.
+     * @throws Exception If failed.
+     */
+    protected final Ignite startGrids(int cnt) throws Exception {
+        assert cnt > 0;
+
+        Ignite ignite = null;
+
+        for (int i = 0; i < cnt; i++)
+            if (ignite == null)
+                ignite = startGrid(i);
+            else
+                startGrid(i);
+
+        checkTopology(cnt);
+
+        assert ignite != null;
+
+        return ignite;
+    }
+
+    /**
+     * @param cnt Grid count.
+     * @return First started grid.
+     * @throws Exception If failed.
+     */
+    protected Ignite startGridsMultiThreaded(int cnt) throws Exception {
+        if (cnt == 1)
+            return startGrids(1);
+
+        Ignite ignite = startGridsMultiThreaded(0, cnt);
+
+        checkTopology(cnt);
+
+        return ignite;
+    }
+
+    /**
+     * @param init Start grid index.
+     * @param cnt Grid count.
+     * @return First started grid.
+     * @throws Exception If failed.
+     */
+    protected final Ignite startGridsMultiThreaded(int init, int cnt) throws Exception {
+        assert init >= 0;
+        assert cnt > 0;
+
+        info("Starting grids: " + cnt);
+
+        final AtomicInteger gridIdx = new AtomicInteger(init);
+
+        GridTestUtils.runMultiThreaded(
+            new Callable<Object>() {
+                @Nullable @Override public Object call() throws Exception {
+                    startGrid(gridIdx.getAndIncrement());
+
+                    return null;
+                }
+            },
+            cnt,
+            "grid-starter-" + getName()
+        );
+
+        assert gridIdx.get() - init == cnt;
+
+        return grid(init);
+    }
+
+    /**
+     * @param cnt Grid count
+     * @throws Exception If an error occurs.
+     */
+    @SuppressWarnings({"BusyWait"})
+    protected void checkTopology(int cnt) throws Exception {
+        for (int j = 0; j < 10; j++) {
+            boolean topOk = true;
+
+            for (int i = 0; i < cnt; i++) {
+                if (cnt != grid(i).nodes().size()) {
+                    U.warn(log, "Grid size is incorrect (will re-run check in 1000 ms) " +
+                        "[name=" + grid(i).name() + ", size=" + grid(i).nodes().size() + ']');
+
+                    topOk = false;
+
+                    break;
+                }
+            }
+
+            if (topOk)
+                return;
+            else
+                Thread.sleep(1000);
+        }
+
+        throw new Exception("Failed to wait for proper topology.");
+    }
+
+    /** */
+    protected void stopGrid() {
+        stopGrid(getTestGridName());
+    }
+
+    /**
+     * Starts new grid with given index.
+     *
+     * @param idx Index of the grid to start.
+     * @return Started grid.
+     * @throws Exception If anything failed.
+     */
+    protected Ignite startGrid(int idx) throws Exception {
+        return startGrid(getTestGridName(idx));
+    }
+
+    /**
+     * Starts new grid with given index and Spring application context.
+     *
+     * @param idx Index of the grid to start.
+     * @param ctx Spring context.
+     * @return Started grid.
+     * @throws Exception If anything failed.
+     */
+    protected Ignite startGrid(int idx, GridSpringResourceContext ctx) throws Exception {
+        return startGrid(getTestGridName(idx), ctx);
+    }
+
+    /**
+     * Starts new grid with given name.
+     *
+     * @param gridName Grid name.
+     * @return Started grid.
+     * @throws Exception If failed.
+     */
+    protected Ignite startGrid(String gridName) throws Exception {
+        return startGrid(gridName, (GridSpringResourceContext)null);
+    }
+
+    /**
+     * Starts new grid with given name.
+     *
+     * @param gridName Grid name.
+     * @param ctx Spring context.
+     * @return Started grid.
+     * @throws Exception If failed.
+     */
+    protected Ignite startGrid(String gridName, GridSpringResourceContext ctx) throws Exception {
+        return GridGainEx.start(optimize(getConfiguration(gridName)), ctx);
+    }
+
+    /**
+     * Optimizes configuration to achieve better test performance.
+     *
+     * @param cfg Configuration.
+     * @return Optimized configuration (by modifying passed in one).
+     */
+    protected IgniteConfiguration optimize(IgniteConfiguration cfg) {
+        // TODO: GG-4048: propose another way to avoid network overhead in tests.
+        if (cfg.getLocalHost() == null) {
+            if (cfg.getDiscoverySpi() instanceof TcpDiscoverySpi)
+                cfg.setLocalHost("127.0.0.1");
+            else
+                cfg.setLocalHost(getTestResources().getLocalHost());
+        }
+
+        // Do not add redundant data if it is not needed.
+        if (cfg.getIncludeProperties() == null)
+            cfg.setIncludeProperties();
+
+        return cfg;
+    }
+
+    /**
+     * @param gridName Grid name.
+     */
+    protected void stopGrid(@Nullable String gridName) {
+        stopGrid(gridName, true);
+    }
+
+    /**
+     * @param gridName Grid name.
+     * @param cancel Cancel flag.
+     */
+    @SuppressWarnings({"deprecation"})
+    protected void stopGrid(@Nullable String gridName, boolean cancel) {
+        try {
+            Ignite ignite = G.ignite(gridName);
+
+            assert ignite != null : "GridGain returned null grid for name: " + gridName;
+
+            info(">>> Stopping grid [name=" + ignite.name() + ", id=" + ignite.cluster().localNode().id() + ']');
+
+            G.stop(gridName, cancel);
+        }
+        catch (IllegalStateException ignored) {
+            // Ignore error if grid already stopped.
+        }
+        catch (Throwable e) {
+            error("Failed to stop grid [gridName=" + gridName + ", cancel=" + cancel + ']', e);
+
+            stopGridErr = true;
+        }
+    }
+
+    /**
+     *
+     */
+    protected void stopAllGrids() {
+        stopAllGrids(true);
+    }
+
+    /**
+     * @param cancel Cancel flag.
+     */
+    protected void stopAllGrids(boolean cancel) {
+        List<Ignite> ignites = G.allGrids();
+
+        for (Ignite g : ignites)
+            stopGrid(g.name(), cancel);
+
+        assert G.allGrids().isEmpty();
+    }
+
+    /**
+     * @param cancel Cancel flag.
+     */
+    protected void stopAllClients(boolean cancel) {
+        List<Ignite> ignites = G.allGrids();
+
+        for (Ignite g : ignites) {
+            if (g.cluster().localNode().isClient())
+                stopGrid(g.name(), cancel);
+        }
+    }
+
+    /**
+     * @param cancel Cancel flag.
+     */
+    protected void stopAllServers(boolean cancel) {
+        List<Ignite> ignites = G.allGrids();
+
+        for (Ignite g : ignites) {
+            if (!g.cluster().localNode().isClient())
+                stopGrid(g.name(), cancel);
+        }
+    }
+
+    /**
+     * @param ignite Grid
+     * @param cnt Count
+     * @throws IgniteCheckedException If failed.
+     */
+    @SuppressWarnings({"BusyWait"})
+    protected void waitForRemoteNodes(Ignite ignite, int cnt) throws IgniteCheckedException {
+        while (true) {
+            Collection<ClusterNode> nodes = ignite.cluster().forRemotes().nodes();
+
+            if (nodes != null && nodes.size() >= cnt)
+                return;
+
+            try {
+                Thread.sleep(100);
+            }
+            catch (InterruptedException ignored) {
+                throw new IgniteCheckedException("Interrupted while waiting for remote nodes [gridName=" + ignite.name() +
+                    ", count=" + cnt + ']');
+            }
+        }
+    }
+
+    /**
+     * @param ignites Grids
+     * @throws IgniteCheckedException If failed.
+     */
+    protected void waitForDiscovery(Ignite... ignites) throws IgniteCheckedException {
+        assert ignites != null;
+        assert ignites.length > 1;
+
+        for (Ignite ignite : ignites)
+            waitForRemoteNodes(ignite, ignites.length - 1);
+    }
+
+    /**
+     * Gets grid for given name.
+     *
+     * @param name Name.
+     * @return Grid instance.
+     */
+    protected GridEx grid(String name) {
+        return (GridEx)G.ignite(name);
+    }
+
+    /**
+     * Gets grid for given index.
+     *
+     * @param idx Index.
+     * @return Grid instance.
+     */
+    protected GridEx grid(int idx) {
+        return (GridEx)G.ignite(getTestGridName(idx));
+    }
+
+    /**
+     * @param idx Index.
+     * @return Ignite instance.
+     */
+    protected Ignite ignite(int idx) {
+        return G.ignite(getTestGridName(idx));
+    }
+
+    /**
+     * Gets grid for given test.
+     *
+     * @return Grid for given test.
+     */
+    protected GridEx grid() {
+        return (GridEx)G.ignite(getTestGridName());
+    }
+
+    /**
+     * Starts grid using provided grid name and spring config location.
+     * <p>
+     * Note that grids started this way should be stopped with {@code G.stop(..)} methods.
+     *
+     * @param gridName Grid name.
+     * @param springCfgPath Path to config file.
+     * @return Grid Started grid.
+     * @throws Exception If failed.
+     */
+    protected Ignite startGrid(String gridName, String springCfgPath) throws Exception {
+        return startGrid(gridName, loadConfiguration(springCfgPath));
+    }
+
+    /**
+     * Starts grid using provided grid name and config.
+     * <p>
+     * Note that grids started this way should be stopped with {@code G.stop(..)} methods.
+     *
+     * @param gridName Grid name.
+     * @param cfg Config.
+     * @return Grid Started grid.
+     * @throws Exception If failed.
+     */
+    protected Ignite startGrid(String gridName, IgniteConfiguration cfg) throws Exception {
+        cfg.setGridName(gridName);
+
+        return G.start(cfg);
+    }
+
+    /**
+     * Loads configuration from the given Spring XML file.
+     *
+     * @param springCfgPath Path to file.
+     * @return Grid configuration.
+     * @throws IgniteCheckedException If load failed.
+     */
+    @SuppressWarnings("deprecation")
+    protected IgniteConfiguration loadConfiguration(String springCfgPath) throws IgniteCheckedException {
+        URL cfgLocation = U.resolveGridGainUrl(springCfgPath);
+
+        assert cfgLocation != null;
+
+        ApplicationContext springCtx;
+
+        try {
+            springCtx = new FileSystemXmlApplicationContext(cfgLocation.toString());
+        }
+        catch (BeansException e) {
+            throw new IgniteCheckedException("Failed to instantiate Spring XML application context.", e);
+        }
+
+        Map cfgMap;
+
+        try {
+            // Note: Spring is not generics-friendly.
+            cfgMap = springCtx.getBeansOfType(IgniteConfiguration.class);
+        }
+        catch (BeansException e) {
+            throw new IgniteCheckedException("Failed to instantiate bean [type=" + IgniteConfiguration.class + ", err=" +
+                e.getMessage() + ']', e);
+        }
+
+        if (cfgMap == null)
+            throw new IgniteCheckedException("Failed to find a single grid factory configuration in: " + springCfgPath);
+
+        if (cfgMap.isEmpty())
+            throw new IgniteCheckedException("Can't find grid factory configuration in: " + springCfgPath);
+        else if (cfgMap.size() > 1)
+            throw new IgniteCheckedException("More than one configuration provided for cache load test: " + cfgMap.values());
+
+        IgniteConfiguration cfg = (IgniteConfiguration)cfgMap.values().iterator().next();
+
+        cfg.setNodeId(UUID.randomUUID());
+
+        return cfg;
+    }
+
+    /**
+     * @param idx Index of the grid to stop.
+     */
+    protected void stopGrid(int idx) {
+        stopGrid(getTestGridName(idx), false);
+    }
+
+    /**
+     * @param idx Grid index.
+     * @param cancel Cancel flag.
+     */
+    @SuppressWarnings("deprecation")
+    protected void stopGrid(int idx, boolean cancel) {
+        String gridName = getTestGridName(idx);
+
+        try {
+            Ignite ignite = G.ignite(gridName);
+
+            assert ignite != null : "GridGain returned null grid for name: " + gridName;
+
+            info(">>> Stopping grid [name=" + ignite.name() + ", id=" + ignite.cluster().localNode().id() + ']');
+
+            G.stop(gridName, cancel);
+        }
+        catch (IllegalStateException ignored) {
+            // Ignore error if grid already stopped.
+        }
+        catch (Throwable e) {
+            error("Failed to stop grid [gridName=" + gridName + ", cancel=" + cancel + ']', e);
+
+            stopGridErr = true;
+        }
+    }
+
+    /**
+     * @param idx Index of the grid to stop.
+     */
+    protected void stopAndCancelGrid(int idx) {
+        stopGrid(getTestGridName(idx), true);
+    }
+
+    /**
+     * @return Grid test configuration.
+     * @throws Exception If failed.
+     */
+    protected IgniteConfiguration getConfiguration() throws Exception {
+        // Generate unique grid name.
+        return getConfiguration(getTestGridName());
+    }
+
+    /**
+     * This method should be overridden by subclasses to change configuration parameters.
+     *
+     * @param gridName Grid name.
+     * @return Grid configuration used for starting of grid.
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings("deprecation")
+    protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
+        IgniteConfiguration cfg = getConfiguration(gridName, getTestResources());
+
+        cfg.setNodeId(null);
+
+        return cfg;
+    }
+
+    /**
+     * This method should be overridden by subclasses to change configuration parameters.
+     *
+     * @return Grid configuration used for starting of grid.
+     * @param rsrcs Resources.
+     * @throws Exception If failed.
+     */
+    protected IgniteConfiguration getConfiguration(GridTestResources rsrcs) throws Exception {
+        return getConfiguration(getTestGridName(), rsrcs);
+    }
+
+    /**
+     * @return Generated unique test grid name.
+     */
+    public String getTestGridName() {
+        String[] parts = getClass().getName().split("\\.");
+
+        return parts[parts.length - 2] + '.' + parts[parts.length - 1];
+    }
+
+    /**
+     * @param idx Index of the grid.
+     * @return Indexed grid name.
+     */
+    public String getTestGridName(int idx) {
+        return getTestGridName() + idx;
+    }
+
+    /**
+     * Parses test grid index from test grid name.
+     *
+     * @param testGridName Test grid name, returned by {@link #getTestGridName(int)}.
+     * @return Test grid index.
+     */
+    public int getTestGridIndex(String testGridName) {
+        return Integer.parseInt(testGridName.substring(getTestGridName().length()));
+    }
+
+    /**
+     * @return {@code True} if system property -DDEBUG is set.
+     */
+    public boolean isDebug() {
+        return System.getProperty("DEBUG") != null;
+    }
+
+    /**
+     * @param marshaller Marshaller to get checkpoint path for.
+     * @return Path for specific marshaller.
+     */
+    @SuppressWarnings({"IfMayBeConditional", "deprecation"})
+    protected String getDefaultCheckpointPath(IgniteMarshaller marshaller) {
+        if (marshaller instanceof IgniteJdkMarshaller)
+            return SharedFsCheckpointSpi.DFLT_DIR_PATH + "/jdk/";
+        else
+            return SharedFsCheckpointSpi.DFLT_DIR_PATH + '/' + marshaller.getClass().getSimpleName() + '/';
+    }
+
+    /**
+     * @param name Name to mask.
+     * @return Masked name.
+     */
+    private String maskNull(String name) {
+        return name == null ? NULL_NAME : name;
+    }
+
+    /**
+     * @return GridGain home.
+     */
+    protected String home() {
+        return getTestResources().getGridgainHome();
+    }
+
+    /**
+     * This method should be overridden by subclasses to change configuration parameters.
+     *
+     * @return Grid configuration used for starting of grid.
+     * @param gridName Grid name.
+     * @param rsrcs Resources.
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings("deprecation")
+    protected IgniteConfiguration getConfiguration(String gridName, GridTestResources rsrcs) throws Exception {
+        IgniteConfiguration cfg = new IgniteConfiguration();
+
+        cfg.setGridName(gridName);
+        cfg.setGridLogger(rsrcs.getLogger());
+        cfg.setMarshaller(rsrcs.getMarshaller());
+        cfg.setNodeId(rsrcs.getNodeId());
+        cfg.setGridGainHome(rsrcs.getGridgainHome());
+        cfg.setMBeanServer(rsrcs.getMBeanServer());
+        cfg.setPeerClassLoadingEnabled(true);
+        cfg.setMetricsLogFrequency(0);
+
+        TcpCommunicationSpi commSpi = new TcpCommunicationSpi();
+
+        commSpi.setLocalPort(GridTestUtils.getNextCommPort(getClass()));
+        commSpi.setTcpNoDelay(true);
+
+        cfg.setCommunicationSpi(commSpi);
+
+        TcpDiscoverySpi discoSpi = new TcpDiscoverySpi();
+
+        if (isDebug()) {
+            discoSpi.setMaxMissedHeartbeats(Integer.MAX_VALUE);
+            cfg.setNetworkTimeout(Long.MAX_VALUE);
+        }
+        else {
+            // Set network timeout to 10 sec to avoid unexpected p2p class loading errors.
+            cfg.setNetworkTimeout(10000);
+
+            // Increase max missed heartbeats to avoid unexpected node fails.
+            discoSpi.setMaxMissedHeartbeats(30);
+        }
+
+        // Set heartbeat interval to 1 second to speed up tests.
+        discoSpi.setHeartbeatFrequency(1000);
+
+        String mcastAddr = GridTestUtils.getNextMulticastGroup(getClass());
+
+        if (!F.isEmpty(mcastAddr)) {
+            TcpDiscoveryMulticastIpFinder ipFinder = new TcpDiscoveryMulticastIpFinder();
+
+            ipFinder.setMulticastGroup(mcastAddr);
+            ipFinder.setMulticastPort(GridTestUtils.getNextMulticastPort(getClass()));
+
+            discoSpi.setIpFinder(ipFinder);
+        }
+
+        cfg.setDiscoverySpi(discoSpi);
+
+        SharedFsCheckpointSpi cpSpi = new SharedFsCheckpointSpi();
+
+        Collection<String> paths = new ArrayList<>();
+
+        paths.add(getDefaultCheckpointPath(cfg.getMarshaller()));
+
+        cpSpi.setDirectoryPaths(paths);
+
+        cfg.setCheckpointSpi(cpSpi);
+
+        cfg.setRestEnabled(false);
+
+        cfg.setIncludeEventTypes(IgniteEventType.EVTS_ALL);
+
+        return cfg;
+    }
+
+    /**
+     * @return New cache configuration with modified defaults.
+     */
+    public static CacheConfiguration defaultCacheConfiguration() {
+        CacheConfiguration cfg = new CacheConfiguration();
+
+        cfg.setStartSize(1024);
+        cfg.setQueryIndexEnabled(true);
+        cfg.setAtomicWriteOrderMode(PRIMARY);
+        cfg.setAtomicityMode(TRANSACTIONAL);
+        cfg.setDistributionMode(NEAR_PARTITIONED);
+        cfg.setWriteSynchronizationMode(FULL_SYNC);
+        cfg.setEvictionPolicy(null);
+
+        return cfg;
+    }
+
+    /**
+     * Gets external class loader.
+     *
+     * @return External class loader.
+     */
+    protected static ClassLoader getExternalClassLoader() {
+        String path = GridTestProperties.getProperty("p2p.uri.cls");
+
+        try {
+            return new URLClassLoader(new URL[] {new URL(path)}, U.gridClassLoader());
+        }
+        catch (MalformedURLException e) {
+            throw new RuntimeException("Failed to create URL: " + path, e);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void tearDown() throws Exception {
+        long dur = System.currentTimeMillis() - ts;
+
+        info(">>> Stopping test: " + getName() + " in " + dur + " ms <<<");
+
+        TestCounters cntrs = getTestCounters();
+
+        if (isDebug())
+            info("Test counters [numOfTests=" + cntrs.getNumberOfTests() + ", started=" + cntrs.getStarted() +
+                ", stopped=" + cntrs.getStopped() + ']');
+
+        try {
+            afterTest();
+        }
+        finally {
+            if (isLastTest()) {
+                info(">>> Stopping test class: " + getClass().getSimpleName() + " <<<");
+
+                TestCounters counters = getTestCounters();
+
+                // Stop all threads started by runMultithreaded() methods.
+                GridTestUtils.stopThreads(log);
+
+                // Safety.
+                getTestResources().stopThreads();
+
+                // Set reset flags, so counters will be reset on the next setUp.
+                counters.setReset(true);
+
+                afterTestsStopped();
+
+                if (startGrid)
+                    G.stop(getTestGridName(), true);
+
+                // Remove counters.
+                tests.remove(getClass());
+
+                // Remove resources cached in static, if any.
+                GridClassLoaderCache.clear();
+                IgniteOptimizedMarshaller.clearCache();
+                IgniteMarshallerExclusions.clearCache();
+                GridEnumCache.clear();
+            }
+
+            Thread.currentThread().setContextClassLoader(clsLdr);
+
+            clsLdr = null;
+        }
+    }
+
+    /**
+     * @return First test flag.
+     */
+    protected boolean isFirstTest() {
+        TestCounters cntrs = getTestCounters();
+
+        return cntrs.getStarted() == 1 && cntrs.getStopped() == 0;
+    }
+
+    /**
+     * @return Last test flag.
+     */
+    protected boolean isLastTest() {
+        TestCounters cntrs = getTestCounters();
+
+        return cntrs.getStopped() == cntrs.getNumberOfTests();
+    }
+
+    /**
+     * @return Test counters.
+     */
+    protected synchronized TestCounters getTestCounters() {
+        TestCounters tc = tests.get(getClass());
+
+        if (tc == null)
+            tests.put(getClass(), tc = new TestCounters());
+
+        return tc;
+    }
+
+    /** {@inheritDoc} */
+    @SuppressWarnings({"ProhibitedExceptionDeclared"})
+    @Override protected void runTest() throws Throwable {
+        final AtomicReference<Throwable> ex = new AtomicReference<>();
+
+        Thread runner = new Thread("test-runner") {
+            @Override public void run() {
+                try {
+                    runTestInternal();
+                }
+                catch (Throwable e) {
+                    IgniteClosure<Throwable, Throwable> hnd = errorHandler();
+
+                    ex.set(hnd != null ? hnd.apply(e) : e);
+                }
+            }
+        };
+
+        runner.start();
+
+        runner.join(isDebug() ? 0 : getTestTimeout());
+
+        if (runner.isAlive()) {
+            U.error(log,
+                "Test has been timed out and will be interrupted (threads dump will be taken before interruption) [" +
+                "test=" + getName() + ", timeout=" + getTestTimeout() + ']');
+
+            // We dump threads to stdout, because we can loose logs in case
+            // the build is cancelled on TeamCity.
+            U.dumpThreads(null);
+
+            U.dumpThreads(log);
+
+            U.interrupt(runner);
+
+            U.join(runner, log);
+
+            throw new TimeoutException("Test has been timed out [test=" + getName() + ", timeout=" +
+                getTestTimeout() + ']' );
+        }
+
+        Throwable t = ex.get();
+
+        if (t != null) {
+            U.error(log, "Test failed.", t);
+
+            throw t;
+        }
+
+        assert !stopGridErr : "Error occurred on grid stop (see log for more details).";
+    }
+
+    /**
+     * @return Error handler to process all uncaught exceptions of the test run
+     *      ({@code null} by default).
+     */
+    protected IgniteClosure<Throwable, Throwable> errorHandler() {
+        return null;
+    }
+
+    /**
+     * @throws Throwable If failed.
+     */
+    @SuppressWarnings({"ProhibitedExceptionDeclared"})
+    private void runTestInternal() throws Throwable {
+        super.runTest();
+    }
+
+    /**
+     * @return Test case timeout.
+     */
+    protected long getTestTimeout() {
+        return getDefaultTestTimeout();
+    }
+
+    /**
+     * @return Default test case timeout.
+     */
+    private long getDefaultTestTimeout() {
+        String timeout = GridTestProperties.getProperty("test.timeout");
+
+        if (timeout != null)
+            return Long.parseLong(timeout);
+
+        return DFLT_TEST_TIMEOUT;
+    }
+
+    /**
+     * Test counters.
+     */
+    protected class TestCounters {
+        /** */
+        private int numOfTests = -1;
+
+        /** */
+        private int started;
+
+        /** */
+        private int stopped;
+
+        /** */
+        private boolean reset;
+
+        /** */
+        private GridTestResources rsrcs = new GridTestResources();
+
+        /**
+         * @return Reset flag.
+         */
+        public boolean isReset() {
+            return reset;
+        }
+
+        /**
+         * @return Test resources.
+         */
+        public GridTestResources getTestResources() {
+            return rsrcs;
+        }
+
+        /**
+         * @param reset Reset flag.
+         */
+        public void setReset(boolean reset) {
+            this.reset = reset;
+        }
+
+        /** */
+        public void reset() {
+            numOfTests = -1;
+            started = 0;
+            stopped = 0;
+            reset = false;
+        }
+
+        /**
+         * @return Started flag.
+         */
+        public int getStarted() {
+            return started;
+        }
+
+        /**
+         * @param started Started flag.
+         */
+        public void setStarted(int started) {
+            this.started = started;
+        }
+
+        /**
+         * @return Stopped flag.
+         */
+        public int getStopped() {
+            return stopped;
+        }
+
+        /**
+         * @param stopped Stopped flag.
+         */
+        public void setStopped(int stopped) {
+            this.stopped = stopped;
+        }
+
+        /** */
+        public void incrementStarted() {
+            if (isDebug())
+                info("Incrementing started tests counter.");
+
+            started++;
+        }
+
+        /** */
+        public void incrementStopped() {
+            if (isDebug())
+                info("Incrementing stopped tests counter.");
+
+            stopped++;
+        }
+
+        /**
+         * @return Number of tests
+         */
+        public int getNumberOfTests() {
+            if (numOfTests == -1) {
+                int cnt = 0;
+
+                for (Method m : GridAbstractTest.this.getClass().getMethods())
+                    if (m.getDeclaringClass().getName().startsWith("org.gridgain") ||
+                        m.getDeclaringClass().getName().startsWith("org.apache.ignite")) {
+                        if (m.getName().startsWith("test") && Modifier.isPublic(m.getModifiers()))
+                            cnt++;
+                    }
+
+                numOfTests = cnt;
+            }
+
+            countTestCases();
+
+            return numOfTests;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestIgnite.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestIgnite.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestIgnite.java
new file mode 100644
index 0000000..77eb689
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestIgnite.java
@@ -0,0 +1,224 @@
+/* @java.file.header */
+
+/*  _________        _____ __________________        _____
+ *  __  ____/___________(_)______  /__  ____/______ ____(_)_______
+ *  _  / __  __  ___/__  / _  __  / _  / __  _  __ `/__  / __  __ \
+ *  / /_/ /  _  /    _  /  / /_/ /  / /_/ /  / /_/ / _  /  _  / / /
+ *  \____/   /_/     /_/   \_,__/   \____/   \__,_/  /_/   /_/ /_/
+ */
+
+package org.apache.ignite.testframework.junits;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.hadoop.*;
+import org.apache.ignite.marshaller.IgniteMarshaller;
+import org.apache.ignite.plugin.*;
+import org.apache.ignite.plugin.security.*;
+import org.apache.ignite.product.*;
+import org.jetbrains.annotations.*;
+
+import javax.management.*;
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * Ignite mock.
+ */
+public class GridTestIgnite implements Ignite {
+    /** Ignite name */
+    private final String name;
+
+    /** Local host. */
+    private final String locHost;
+
+    /** */
+    private final UUID nodeId;
+
+    /** */
+    private IgniteMarshaller marshaller;
+
+    /** */
+    private final MBeanServer jmx;
+
+    /** */
+    private final String home;
+
+    /**
+     * Mock values
+     *
+     * @param name Name.
+     * @param locHost Local host.
+     * @param nodeId Node ID.
+     * @param marshaller Marshaller.
+     * @param jmx Jmx Bean Server.
+     * @param home Ignite home.
+     */
+    public GridTestIgnite(
+        String name, String locHost, UUID nodeId, IgniteMarshaller marshaller, MBeanServer jmx, String home) {
+        this.locHost = locHost;
+        this.nodeId = nodeId;
+        this.marshaller = marshaller;
+        this.jmx = jmx;
+        this.home = home;
+        this.name = name;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String name() {
+        return name;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteLogger log() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteConfiguration configuration() {
+        IgniteConfiguration cfg = new IgniteConfiguration();
+
+        cfg.setMarshaller(marshaller);
+        cfg.setNodeId(nodeId);
+        cfg.setMBeanServer(jmx);
+        cfg.setGridGainHome(home);
+        cfg.setLocalHost(locHost);
+
+        return cfg;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCluster cluster() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCompute compute() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCompute compute(ClusterGroup prj) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteMessaging message() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteMessaging message(ClusterGroup prj) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteEvents events() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteEvents events(ClusterGroup prj) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteManaged managed() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteManaged managed(ClusterGroup prj) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public ExecutorService executorService() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public ExecutorService executorService(ClusterGroup prj) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteProduct product() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteScheduler scheduler() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public GridSecurity security() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgnitePortables portables() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> GridCache<K, V> cache(@Nullable String name) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<GridCache<?, ?>> caches() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> jcache(@Nullable String name) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteTransactions transactions() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteDataLoader<K, V> dataLoader(@Nullable String cacheName) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteFs fileSystem(String name) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<IgniteFs> fileSystems() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public GridHadoop hadoop() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteStreamer streamer(@Nullable String name) {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<IgniteStreamer> streamers() {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T extends IgnitePlugin> T plugin(String name) throws PluginNotFoundException {
+        return null;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void close() throws IgniteCheckedException {}
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java
new file mode 100644
index 0000000..14d8817
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestKernalContext.java
@@ -0,0 +1,85 @@
+/*
+ * 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.ignite.testframework.junits;
+
+import org.apache.ignite.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.internal.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.testframework.*;
+
+import java.util.*;
+
+/**
+ * Test context.
+ */
+public class GridTestKernalContext extends GridKernalContextImpl {
+    /**
+     *
+     */
+    public GridTestKernalContext() {
+        super(null,
+            new GridKernal(null),
+            new IgniteConfiguration(),
+            new GridKernalGatewayImpl(null),
+            null,
+            false);
+
+        GridTestUtils.setFieldValue(grid(), "cfg", config());
+    }
+
+    /**
+     * @param log Logger to use in context config.
+     */
+    public GridTestKernalContext(IgniteLogger log) {
+        this();
+
+        config().setGridLogger(log);
+    }
+
+    /**
+     * Starts everything added (in the added order).
+     *
+     * @throws IgniteCheckedException If failed
+     */
+    public void start() throws IgniteCheckedException {
+        for (GridComponent comp : this)
+            comp.start();
+    }
+
+    /**
+     * Stops everything added.
+     *
+     * @param cancel Cancel parameter.
+     * @throws IgniteCheckedException If failed.
+     */
+    public void stop(boolean cancel) throws IgniteCheckedException {
+        List<GridComponent> comps = components();
+
+        for (ListIterator<GridComponent> it = comps.listIterator(comps.size()); it.hasPrevious();) {
+            GridComponent comp = it.previous();
+
+            comp.stop(cancel);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override public String toString() {
+        return S.toString(GridTestKernalContext.class, this, super.toString());
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestResources.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestResources.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestResources.java
new file mode 100644
index 0000000..6eee6b1
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridTestResources.java
@@ -0,0 +1,255 @@
+/*
+ * 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.ignite.testframework.junits;
+
+import org.apache.ignite.*;
+import org.apache.ignite.marshaller.*;
+import org.apache.ignite.marshaller.optimized.*;
+import org.apache.ignite.resources.*;
+import org.apache.ignite.thread.*;
+import org.apache.ignite.internal.processors.resource.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.testframework.config.*;
+import org.apache.ignite.testframework.junits.logger.*;
+import org.jetbrains.annotations.*;
+
+import javax.management.*;
+import java.io.*;
+import java.lang.management.*;
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * Test resources for injection.
+ */
+public class GridTestResources {
+    /** */
+    private static final IgniteLogger rootLog = new GridTestLog4jLogger(false);
+
+    /** */
+    private final IgniteLogger log;
+
+    /** Local host. */
+    private final String locHost;
+
+    /** */
+    private final UUID nodeId;
+
+    /** */
+    private IgniteMarshaller marshaller;
+
+    /** */
+    private final MBeanServer jmx;
+
+    /** */
+    private final String home;
+
+    /** */
+    private ThreadPoolExecutor execSvc;
+
+    /** */
+    private GridResourceProcessor rsrcProc;
+
+    /** */
+    public GridTestResources() {
+        log = rootLog.getLogger(getClass());
+        nodeId = UUID.randomUUID();
+        jmx = ManagementFactory.getPlatformMBeanServer();
+        home = U.getGridGainHome();
+        locHost = localHost();
+
+        GridTestKernalContext ctx = new GridTestKernalContext();
+
+        ctx.config().setGridLogger(log);
+
+        rsrcProc = new GridResourceProcessor(ctx);
+    }
+
+    /**
+     * @param jmx JMX server.
+     */
+    public GridTestResources(MBeanServer jmx) {
+        assert jmx != null;
+
+        this.jmx = jmx;
+
+        log = rootLog.getLogger(getClass());
+
+        nodeId = UUID.randomUUID();
+        home = U.getGridGainHome();
+        locHost = localHost();
+
+        GridTestKernalContext ctx = new GridTestKernalContext();
+
+        ctx.config().setGridLogger(log);
+
+        rsrcProc = new GridResourceProcessor(ctx);
+    }
+
+    /**
+     * @param log Logger.
+     */
+    public GridTestResources(IgniteLogger log) {
+        assert log != null;
+
+        this.log = log.getLogger(getClass());
+
+        nodeId = UUID.randomUUID();
+        jmx = ManagementFactory.getPlatformMBeanServer();
+        home = U.getGridGainHome();
+        locHost = localHost();
+
+        GridTestKernalContext ctx = new GridTestKernalContext();
+
+        ctx.config().setGridLogger(log);
+
+        rsrcProc = new GridResourceProcessor(ctx);
+    }
+
+    /**
+     * @return Resource processor.
+     */
+    public GridResourceProcessor resources() {
+        return rsrcProc;
+    }
+
+    /**
+     * @return Local host.
+     */
+    @Nullable private String localHost() {
+        try {
+            return U.getLocalHost().getHostAddress();
+        }
+        catch (IOException e) {
+            System.err.println("Failed to detect local host address.");
+
+            e.printStackTrace();
+
+            return null;
+        }
+    }
+
+    /**
+     * @param prestart Prestart flag.
+     */
+    public void startThreads(boolean prestart) {
+        execSvc = new IgniteThreadPoolExecutor(nodeId.toString(), 40, 40, Long.MAX_VALUE,
+            new LinkedBlockingQueue<Runnable>());
+
+        // Improve concurrency for testing.
+        if (prestart)
+            execSvc.prestartAllCoreThreads();
+    }
+
+    /** */
+    public void stopThreads() {
+        if (execSvc != null) {
+            U.shutdownNow(getClass(), execSvc, log);
+
+            execSvc = null;
+        }
+    }
+
+    /**
+     * @param target Target.
+     * @throws IgniteCheckedException If failed.
+     */
+    public void inject(Object target) throws IgniteCheckedException {
+        assert target != null;
+        assert getLogger() != null;
+
+        rsrcProc.injectBasicResource(target, IgniteLoggerResource.class, getLogger().getLogger(target.getClass()));
+        rsrcProc.injectBasicResource(target, IgniteInstanceResource.class,
+            new GridTestIgnite(null, locHost, nodeId, getMarshaller(), jmx, home));
+    }
+
+    /**
+     * @return Executor service.
+     */
+    public ExecutorService getExecutorService() {
+        return execSvc;
+    }
+
+    /**
+     * @return GridGain home.
+     */
+    public String getGridgainHome() {
+        return home;
+    }
+
+    /**
+     * @return MBean server.
+     */
+    public MBeanServer getMBeanServer() {
+        return jmx;
+    }
+
+    /**
+     * @return Logger for specified class.
+     */
+    public static IgniteLogger getLogger(Class<?> cls) {
+        return rootLog.getLogger(cls);
+    }
+
+    /**
+     * @return Logger.
+     */
+    public IgniteLogger getLogger() {
+        return log;
+    }
+
+    /**
+     * @return Node ID.
+     */
+    public UUID getNodeId() {
+        return nodeId;
+    }
+
+    /**
+     * @return Local host.
+     */
+    public String getLocalHost() {
+        return locHost;
+    }
+
+    /**
+     * @return Marshaller.
+     * @throws IgniteCheckedException If failed.
+     */
+    @SuppressWarnings("unchecked")
+    public synchronized IgniteMarshaller getMarshaller() throws IgniteCheckedException {
+        if (marshaller == null) {
+            String marshallerName = GridTestProperties.getProperty("marshaller.class");
+
+            if (marshallerName == null)
+                marshaller = new IgniteOptimizedMarshaller();
+            else {
+                try {
+                    Class<? extends IgniteMarshaller> cls = (Class<? extends IgniteMarshaller>)Class.forName(marshallerName);
+
+                    marshaller = cls.newInstance();
+                }
+                catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
+                    throw new IgniteCheckedException("Failed to create test marshaller [marshaller=" + marshallerName + ']', e);
+                }
+            }
+        }
+
+        return marshaller;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java
new file mode 100644
index 0000000..59f9d8f
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/GridAbstractCacheStoreSelfTest.java
@@ -0,0 +1,563 @@
+/*
+ * 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.ignite.testframework.junits.cache;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.store.*;
+import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.transactions.*;
+import org.apache.ignite.internal.util.lang.*;
+import org.apache.ignite.internal.util.typedef.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.testframework.*;
+import org.apache.ignite.testframework.junits.common.*;
+import org.jetbrains.annotations.*;
+
+import javax.cache.*;
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * Abstract cache store test.
+ */
+public abstract class GridAbstractCacheStoreSelfTest<T extends CacheStore<Object, Object>>
+    extends GridCommonAbstractTest {
+    /** */
+    protected final T store;
+
+    /** */
+    protected TestThreadLocalCacheSession ses = new TestThreadLocalCacheSession();
+
+    /**
+     * @throws Exception If failed.
+     */
+    @SuppressWarnings({"AbstractMethodCallInConstructor", "OverriddenMethodCallDuringObjectConstruction"})
+    protected GridAbstractCacheStoreSelfTest() throws Exception {
+        super(false);
+
+        store = store();
+
+        inject(store);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testStore() throws Exception {
+        // Create dummy transaction
+        IgniteTx tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        store.write(new CacheEntryImpl<>("k1", "v1"));
+        store.write(new CacheEntryImpl<>("k2", "v2"));
+
+        store.txEnd(true);
+
+        ses.newSession(null);
+
+        assertEquals("v1", store.load("k1"));
+        assertEquals("v2", store.load("k2"));
+        assertNull(store.load("k3"));
+
+        ses.newSession(tx);
+
+        store.delete("k1");
+
+        store.txEnd(true);
+
+        ses.newSession(null);
+
+        assertNull(store.load("k1"));
+        assertEquals("v2", store.load("k2"));
+        assertNull(store.load("k3"));
+    }
+
+    /**
+     * @throws IgniteCheckedException if failed.
+     */
+    public void testRollback() throws IgniteCheckedException {
+        IgniteTx tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        // Put.
+        store.write(new CacheEntryImpl<>("k1", "v1"));
+
+        store.txEnd(false); // Rollback.
+
+        tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        assertNull(store.load("k1"));
+
+        // Put all.
+        assertNull(store.load("k2"));
+
+        Collection<Cache.Entry<? extends Object, ? extends Object>> col = new ArrayList<>();
+
+        col.add(new CacheEntryImpl<>("k2", "v2"));
+
+        store.writeAll(col);
+
+        store.txEnd(false); // Rollback.
+
+        tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        assertNull(store.load("k2"));
+
+        col = new ArrayList<>();
+
+        col.add(new CacheEntryImpl<>("k3", "v3"));
+
+        store.writeAll(col);
+
+        store.txEnd(true); // Commit.
+
+        tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        assertEquals("v3", store.load("k3"));
+
+        store.write(new CacheEntryImpl<>("k4", "v4"));
+
+        store.txEnd(false); // Rollback.
+
+        tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        assertNull(store.load("k4"));
+
+        assertEquals("v3", store.load("k3"));
+
+        // Remove.
+        store.delete("k3");
+
+        store.txEnd(false); // Rollback.
+
+        tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        assertEquals("v3", store.load("k3"));
+
+        // Remove all.
+        store.deleteAll(Arrays.asList("k3"));
+
+        store.txEnd(false); // Rollback.
+
+        tx = new DummyTx();
+
+        ses.newSession(tx);
+
+        assertEquals("v3", store.load("k3"));
+    }
+
+    /**
+     * @throws IgniteCheckedException if failed.
+     */
+    public void testAllOpsWithTXNoCommit() throws IgniteCheckedException {
+        doTestAllOps(new DummyTx(), false);
+    }
+
+    /**
+     * @throws IgniteCheckedException if failed.
+     */
+    public void testAllOpsWithTXCommit() throws IgniteCheckedException {
+        doTestAllOps(new DummyTx(), true);
+    }
+
+    /**
+     * @throws IgniteCheckedException if failed.
+     */
+    public void testAllOpsWithoutTX() throws IgniteCheckedException {
+        doTestAllOps(null, false);
+    }
+
+    /**
+     * @param tx Transaction.
+     * @param commit Commit.
+     * @throws IgniteCheckedException If failed.
+     */
+    private void doTestAllOps(@Nullable IgniteTx tx, boolean commit) throws IgniteCheckedException {
+        try {
+            ses.newSession(tx);
+
+            store.write(new CacheEntryImpl<>("key1", "val1"));
+
+            if (tx != null && commit) {
+                store.txEnd(true);
+
+                tx = new DummyTx();
+
+                ses.newSession(tx);
+            }
+
+            if (tx == null || commit)
+                assertEquals("val1", store.load("key1"));
+
+            Collection<Cache.Entry<? extends Object, ? extends Object>> col = new ArrayList<>();
+
+            col.add(new CacheEntryImpl<>("key2", "val2"));
+            col.add(new CacheEntryImpl<>("key3", "val3"));
+
+            store.writeAll(col);
+
+            if (tx != null && commit) {
+                store.txEnd(true);
+
+                tx = new DummyTx();
+            }
+
+            if (tx == null || commit) {
+                Map<Object, Object> loaded = store.loadAll(Arrays.asList("key1", "key2", "key3", "no_such_key"));
+
+                for (Map.Entry<Object, Object> e : loaded.entrySet()) {
+                    Object key = e.getKey();
+                    Object val = e.getValue();
+
+                    if ("key1".equals(key))
+                        assertEquals("val1", val);
+
+                    if ("key2".equals(key))
+                        assertEquals("val2", val);
+
+                    if ("key3".equals(key))
+                        assertEquals("val3", val);
+
+                    if ("no_such_key".equals(key))
+                        fail();
+                }
+
+                assertEquals(3, loaded.size());
+            }
+
+            store.deleteAll(Arrays.asList("key2", "key3"));
+
+            if (tx != null && commit) {
+                store.txEnd(true);
+
+                tx = new DummyTx();
+
+                ses.newSession(tx);
+            }
+
+            if (tx == null || commit) {
+                assertNull(store.load("key2"));
+                assertNull(store.load("key3"));
+                assertEquals("val1", store.load("key1"));
+            }
+
+            store.delete("key1");
+
+            if (tx != null && commit) {
+                store.txEnd(true);
+
+                tx = new DummyTx();
+
+                ses.newSession(tx);
+            }
+
+            if (tx == null || commit)
+                assertNull(store.load("key1"));
+        }
+        finally {
+            if (tx != null) {
+                store.txEnd(false);
+
+                ses.newSession(null);
+            }
+        }
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testSimpleMultithreading() throws Exception {
+        final Random rnd = new Random();
+
+        final LinkedBlockingQueue<UUID> queue = new LinkedBlockingQueue<>();
+
+        multithreaded(new Callable<Object>() {
+            @Override public Object call() throws Exception {
+                for (int i = 0; i < 1000; i++) {
+                    IgniteTx tx = rnd.nextBoolean() ? new DummyTx() : null;
+
+                    ses.newSession(tx);
+
+                    int op = rnd.nextInt(10);
+
+                    boolean queueEmpty = false;
+
+                    if (op < 4) { // Load.
+                        UUID key = queue.poll();
+
+                        if (key == null)
+                            queueEmpty = true;
+                        else {
+                            if (rnd.nextBoolean())
+                                assertNotNull(store.load(key));
+                            else {
+                                Map<Object, Object> loaded = store.loadAll(Collections.singleton(key));
+
+                                assertEquals(1, loaded.size());
+
+                                Map.Entry<Object, Object> e = loaded.entrySet().iterator().next();
+
+                                UUID k = (UUID)e.getKey();
+                                UUID v = (UUID)e.getValue();
+
+                                assertTrue(k.equals(v) || (k.getMostSignificantBits() == v.getLeastSignificantBits()
+                                    && k.getLeastSignificantBits() == v.getMostSignificantBits()));
+                            }
+
+                            if (tx != null)
+                                store.txEnd(true);
+
+                            queue.add(key);
+                        }
+                    }
+                    else if (op < 6) { // Remove.
+                        UUID key = queue.poll();
+
+                        if (key == null)
+                            queueEmpty = true;
+                        else {
+                            if (rnd.nextBoolean())
+                                store.delete(key);
+                            else
+                                store.deleteAll(Collections.singleton(key));
+
+                            if (tx != null)
+                                store.txEnd(true);
+                        }
+                    }
+                    else { // Update.
+                        UUID key = queue.poll();
+
+                        if (key == null)
+                            queueEmpty = true;
+                        else {
+                            UUID val = new UUID(key.getLeastSignificantBits(), key.getMostSignificantBits());
+
+                            if (rnd.nextBoolean())
+                                store.write(new CacheEntryImpl<>(key, val));
+                            else {
+                                Collection<Cache.Entry<? extends Object, ? extends Object>> col = new ArrayList<>();
+
+                                col.add(new CacheEntryImpl<>(key, val));
+
+                                store.writeAll(col);
+                            }
+
+                            if (tx != null)
+                                store.txEnd(true);
+
+                            queue.add(key);
+                        }
+                    }
+
+                    if (queueEmpty) { // Add.
+                        UUID key = UUID.randomUUID();
+
+                        if (rnd.nextBoolean())
+                            store.write(new CacheEntryImpl<>(key, key));
+                        else {
+                            Collection<Cache.Entry<? extends Object, ? extends Object>> col = new ArrayList<>();
+
+                            col.add(new CacheEntryImpl<>(key, key));
+
+                            store.writeAll(col);
+                        }
+
+                        if (tx != null)
+                            store.txEnd(true);
+
+                        queue.add(key);
+                    }
+                }
+
+                return null;
+            }
+        }, 37);
+    }
+
+    /**
+     * @param store Store.
+     * @throws Exception If failed.
+     */
+    protected void inject(T store) throws Exception {
+        getTestResources().inject(store);
+
+        GridTestUtils.setFieldValue(store, CacheStore.class, "ses", ses);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTest() throws Exception {
+        super.beforeTest();
+
+        U.startLifecycleAware(F.asList(store));
+
+        final Collection<Object> keys = new ArrayList<>();
+
+        CI2<Object, Object> c = new CI2<Object, Object>() {
+            @Override
+            public void apply(Object k, Object v) {
+                keys.add(k);
+            }
+        };
+
+        store.loadCache(c);
+
+        if (keys.isEmpty())
+            return;
+
+        ses.newSession(null);
+
+        store.deleteAll(keys);
+
+        keys.clear();
+
+        store.loadCache(c);
+
+        assertTrue(keys.isEmpty());
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    @Override protected void afterTest() throws Exception {
+        super.afterTest();
+
+        U.stopLifecycleAware(log, F.asList(store));
+    }
+
+    /**
+     * @return Store.
+     */
+    protected abstract T store();
+
+    /**
+     * Dummy transaction for test purposes.
+     */
+    public static class DummyTx extends GridMetadataAwareAdapter implements IgniteTx {
+        /** */
+        private final IgniteUuid xid = IgniteUuid.randomUuid();
+
+        /** {@inheritDoc} */
+        @Nullable @Override public IgniteUuid xid() {
+            return xid;
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public UUID nodeId() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long threadId() {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long startTime() {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public IgniteTxIsolation isolation() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public IgniteTxConcurrency concurrency() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean implicit() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isInvalidate() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Nullable @Override public IgniteTxState state() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long timeout() {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Override public long timeout(long timeout) {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean setRollbackOnly() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isRollbackOnly() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void commit() throws IgniteCheckedException {
+            // No-op.
+        }
+
+        /** {@inheritDoc} */
+        @Override public void close() throws IgniteCheckedException {
+            // No-op.
+        }
+
+        /** {@inheritDoc} */
+        @Override public IgniteAsyncSupport enableAsync() {
+            throw new UnsupportedOperationException();
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isAsync() {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public <R> IgniteFuture<R> future() {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void rollback() throws IgniteCheckedException {
+            // No-op.
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestCacheSession.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestCacheSession.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestCacheSession.java
new file mode 100644
index 0000000..4500618
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestCacheSession.java
@@ -0,0 +1,65 @@
+/*
+ * 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.ignite.testframework.junits.cache;
+
+import org.apache.ignite.cache.store.*;
+import org.apache.ignite.transactions.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ *
+ */
+public class TestCacheSession implements CacheStoreSession {
+    /** */
+    private IgniteTx tx;
+
+    /** */
+    private Map<Object, Object> props;
+
+    /**
+     *
+     * @param tx Transaction.
+     */
+    public void newSession(@Nullable IgniteTx tx) {
+        this.tx = tx;
+
+        props = null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteTx transaction() {
+        return tx;
+    }
+
+    /** {@inheritDoc} */
+    @SuppressWarnings("unchecked")
+    @Override public <K, V> Map<K, V> properties() {
+        if (props == null)
+            props = U.newHashMap(1);
+
+        return (Map<K, V>)props;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public String cacheName() {
+        return null;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestThreadLocalCacheSession.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestThreadLocalCacheSession.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestThreadLocalCacheSession.java
new file mode 100644
index 0000000..91ccf71
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/cache/TestThreadLocalCacheSession.java
@@ -0,0 +1,65 @@
+/*
+ * 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.ignite.testframework.junits.cache;
+
+import org.apache.ignite.cache.store.*;
+import org.apache.ignite.transactions.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ *
+ */
+public class TestThreadLocalCacheSession implements CacheStoreSession {
+    /** */
+    private final ThreadLocal<TestCacheSession> sesHolder = new ThreadLocal<>();
+
+    /**
+     * @param tx Transaction.
+     */
+    public void newSession(@Nullable IgniteTx tx) {
+        TestCacheSession ses = new TestCacheSession();
+
+        ses.newSession(tx);
+
+        sesHolder.set(ses);
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteTx transaction() {
+        TestCacheSession ses = sesHolder.get();
+
+        return ses != null ? ses.transaction() : null;
+    }
+
+    /** {@inheritDoc} */
+    @SuppressWarnings("unchecked")
+    @Override public <K, V> Map<K, V> properties() {
+        TestCacheSession ses = sesHolder.get();
+
+        return ses != null ? (Map<K, V>)ses.properties() : null;
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public String cacheName() {
+        TestCacheSession ses = sesHolder.get();
+
+        return ses != null ? ses.cacheName() : null;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/bd28003b/modules/core/src/test/java/org/apache/ignite/testframework/junits/common/GridAbstractExamplesTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/common/GridAbstractExamplesTest.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/common/GridAbstractExamplesTest.java
new file mode 100644
index 0000000..9df954a
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/common/GridAbstractExamplesTest.java
@@ -0,0 +1,79 @@
+/*
+ * 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.ignite.testframework.junits.common;
+
+import org.apache.ignite.internal.util.typedef.internal.*;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Base class for examples test.
+ */
+public abstract class GridAbstractExamplesTest extends GridCommonAbstractTest {
+    /** */
+    protected static final String[] EMPTY_ARGS = new String[0];
+
+    /** */
+    protected static final int RMT_NODES_CNT = 3;
+
+    /** */
+    protected static final String RMT_NODE_CFGS = "modules/core/src/test/config/examples.properties";
+
+    /** */
+    protected static final String DFLT_CFG = "examples/config/example-compute.xml";
+
+    /** */
+    private static final Properties rmtCfgs = new Properties();
+
+    /** {@inheritDoc} */
+    @Override protected void afterTest() throws Exception {
+        stopAllGrids();
+    }
+
+    /**
+     * Starts remote nodes.
+     *
+     * @throws Exception If failed.
+     */
+    protected final void startRemoteNodes() throws Exception {
+        String name = getName().replaceFirst("test", "");
+
+        if (rmtCfgs.isEmpty()) {
+            info("Loading remote configs properties from file: " + RMT_NODE_CFGS);
+
+            try (FileReader reader = new FileReader(U.resolveGridGainPath(RMT_NODE_CFGS))) {
+                rmtCfgs.load(reader);
+            }
+        }
+
+        String cfg = rmtCfgs.getProperty(name, defaultConfig());
+
+        info("Config for remote nodes [name=" + name + ", cfg=" + cfg + ", dflt=" + defaultConfig() + "]");
+
+        for (int i = 0; i < RMT_NODES_CNT; i++)
+            startGrid(getTestGridName(i), cfg);
+    }
+
+    /**
+     * @return Default config for this test.
+     */
+    protected String defaultConfig() {
+        return DFLT_CFG;
+    }
+}


Mime
View raw message