Mailing-List: contact commits-help@ignite.incubator.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@ignite.incubator.apache.org
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: sboikov@apache.org
To: commits@ignite.incubator.apache.org
Date: Mon, 13 Jul 2015 06:12:09 -0000
Message-Id: <1f041acef47941ee9507aa6bc890bbb5@git.apache.org>
In-Reply-To: <17a58177518c463895f779b89fc4751f@git.apache.org>
References: <17a58177518c463895f779b89fc4751f@git.apache.org>
Subject: [5/9] incubator-ignite git commit: # ignite-648: Implemented.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java
new file mode 100644
index 0000000..b15b6ef
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteCacheProcessProxy.java
@@ -0,0 +1,602 @@
+/*
+ * 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.multijvm;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.*;
+import org.apache.ignite.cache.query.*;
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.internal.util.future.*;
+import org.apache.ignite.lang.*;
+import org.apache.ignite.mxbean.*;
+import org.jetbrains.annotations.*;
+
+import javax.cache.*;
+import javax.cache.CacheManager;
+import javax.cache.configuration.*;
+import javax.cache.expiry.*;
+import javax.cache.integration.*;
+import javax.cache.processor.*;
+import java.util.*;
+import java.util.concurrent.locks.*;
+
+/**
+ * Ignite cache proxy for ignite instance at another JVM.
+ */
+@SuppressWarnings("TransientFieldInNonSerializableClass")
+public class IgniteCacheProcessProxy<K, V> implements IgniteCache<K, V> {
+    /** Compute. */
+    private final transient IgniteCompute compute;
+
+    /** Cache name. */
+    private final String cacheName;
+
+    /** Grid id. */
+    private final UUID gridId;
+
+    /** With async. */
+    private final boolean isAsync;
+
+    /** Ignite proxy. */
+    private final transient IgniteProcessProxy igniteProxy;
+
+    /**
+     * @param name Name.
+     * @param proxy Ignite Process Proxy.
+     */
+    public IgniteCacheProcessProxy(String name, IgniteProcessProxy proxy) {
+        this(name, false, proxy);
+    }
+
+    /**
+     * @param name Name.
+     * @param async
+     * @param proxy Ignite Process Proxy.
+     */
+    public IgniteCacheProcessProxy(String name, boolean async, IgniteProcessProxy proxy) {
+        cacheName = name;
+        isAsync = async;
+        gridId = proxy.getId();
+        igniteProxy = proxy;
+        compute = proxy.remoteCompute();
+    }
+
+    /**
+     * Returns cache instance. Method to be called from closure at another JVM.
+     *
+     * @return Cache.
+     */
+    private IgniteCache<Object, Object> cache() {
+        IgniteCache cache = Ignition.ignite(gridId).cache(cacheName);
+
+        if (isAsync)
+            cache = cache.withAsync();
+
+        return cache;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCache<K, V> withAsync() {
+        return new IgniteCacheProcessProxy<>(cacheName, true, igniteProxy);
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isAsync() {
+        return isAsync;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <R> IgniteFuture<R> future() {
+        // Return fake future. Future should be called in the same place where operation done.
+        return new IgniteFinishedFutureImpl<>();
+    }
+
+    /** {@inheritDoc} */
+    @Override public <C extends Configuration<K, V>> C getConfiguration(final Class<C> clazz) {
+        final Class cl = clazz;
+
+        return (C)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getConfiguration(cl);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public Entry<K, V> randomEntry() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCache<K, V> withExpiryPolicy(ExpiryPolicy plc) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCache<K, V> withSkipStore() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    @Override public IgniteCache<K, V> withNoRetries() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void loadCache(@Nullable IgniteBiPredicate<K, V> p, @Nullable Object... args) throws CacheException {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void localLoadCache(@Nullable final IgniteBiPredicate<K, V> p, @Nullable final Object... args) throws CacheException {
+        final IgniteBiPredicate pCopy = p;
+
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().localLoadCache(pCopy, args);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public V getAndPutIfAbsent(final K key, final V val) throws CacheException {
+        return (V)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getAndPutIfAbsent(key, val);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public Lock lock(K key) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Lock lockAll(Collection<? extends K> keys) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isLocalLocked(final K key, final boolean byCurrThread) {
+        return compute.call(new IgniteCallable<Boolean>() {
+            @Override public Boolean call() throws Exception {
+                return cache().isLocalLocked(key, byCurrThread);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public <R> QueryCursor<R> query(Query<R> qry) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @SuppressWarnings("unchecked")
+    @Override public Iterable<Entry<K, V>> localEntries(final CachePeekMode... peekModes) throws CacheException {
+        return (Iterable<Entry<K, V>>)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                Collection<Entry> res = new ArrayList<>();
+
+                for (Entry e : cache().localEntries(peekModes))
+                    res.add(e);
+
+                return res;
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public QueryMetrics queryMetrics() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void localEvict(final Collection<? extends K> keys) {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().localEvict(keys);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public V localPeek(final K key, final CachePeekMode... peekModes) {
+        return (V)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().localPeek(key, peekModes);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void localPromote(Set<? extends K> keys) throws CacheException {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public int size(final CachePeekMode... peekModes) throws CacheException {
+        return (int)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().size(peekModes);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public int localSize(final CachePeekMode... peekModes) {
+        return (int)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().localSize(peekModes);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override  public <T> Map<K, EntryProcessorResult<T>> invokeAll(Map<? extends K, ? extends EntryProcessor<K, V, T>> map,
+        Object... args) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public V get(final K key) {
+        return (V)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().get(key);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public Map<K, V> getAll(final Set<? extends K> keys) {
+        return (Map<K, V>)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getAll(keys);
+            }
+        });
+    }
+
+    @Override public Map<K, V> getAllOutTx(final Set<? extends K> keys) {
+        return (Map<K, V>)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getAllOutTx(keys);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean containsKey(final K key) {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().containsKey(key);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override  public void loadAll(Set<? extends K> keys, boolean replaceExistingValues, CompletionListener completionLsnr) {
+        throw new UnsupportedOperationException("Oparetion can't be supported automatically.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean containsKeys(final Set<? extends K> keys) {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().containsKeys(keys);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void put(final K key, final V val) {;
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().put(key, val);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public V getAndPut(final K key, final V val) {
+        return (V)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getAndPut(key, val);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void putAll(final Map<? extends K, ? extends V> map) {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().putAll(map);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean putIfAbsent(final K key, final V val) {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().putIfAbsent(key, val);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean remove(final K key) {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().remove(key);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean remove(final K key, final V oldVal) {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().remove(key, oldVal);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public V getAndRemove(final K key) {
+        return (V)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getAndRemove(key);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean replace(final K key, final V oldVal, final V newVal) {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().replace(key, oldVal, newVal);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean replace(final K key, final V val) {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().replace(key, val);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public V getAndReplace(final K key, final V val) {
+        return (V)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getAndReplace(key, val);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void removeAll(final Set<? extends K> keys) {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().removeAll(keys);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void removeAll() {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                IgniteCache<Object, Object> cache = cache();
+
+                cache.removeAll();
+
+                if (isAsync)
+                    cache.future().get();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void clear() {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().clear();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void clear(final K key) {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().clear(key);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void clearAll(final Set<? extends K> keys) {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().clearAll(keys);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void localClear(final K key) {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().localClear(key);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void localClearAll(final Set<? extends K> keys) {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().localClearAll(keys);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T invoke(final K key, final EntryProcessor<K, V, T> entryProcessor, final Object... arguments) {
+        return (T)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().invoke(key,
+                    (EntryProcessor<Object, Object, Object>)entryProcessor, arguments);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T invoke(final K key, final CacheEntryProcessor<K, V, T> entryProcessor, final Object... arguments) {
+        return (T)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().invoke(key,
+                    (CacheEntryProcessor<Object, Object, Object>)entryProcessor, arguments);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override  public <T> Map<K, EntryProcessorResult<T>> invokeAll(final Set<? extends K> keys, final EntryProcessor<K, V, T> entryProcessor,
+        final Object... args) {
+        return (Map<K, EntryProcessorResult<T>>)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().invokeAll(keys,
+                    (EntryProcessor<Object, Object, Object>)entryProcessor, args);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public String getName() {
+        return (String)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().getName();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public CacheManager getCacheManager() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void close() {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().close();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public void destroy() {
+        compute.run(new IgniteRunnable() {
+            @Override public void run() {
+                cache().destroy();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isClosed() {
+        return (boolean)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                return cache().isClosed();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> T unwrap(final Class<T> clazz) {
+        if (Ignite.class.equals(clazz))
+            return (T)igniteProxy;
+
+        try {
+            return (T)compute.call(new IgniteCallable<Object>() {
+                @Override public Object call() throws Exception {
+                    return cache().unwrap(clazz);
+                }
+            });
+        }
+        catch (Exception e) {
+            throw new IllegalArgumentException("Looks like class " + clazz + " is unmarshallable. Exception type:" + e.getClass(), e);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override  public void registerCacheEntryListener(CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override  public void deregisterCacheEntryListener(CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Iterator<Entry<K, V>> iterator() {
+        final Collection<Entry<K, V>> col = (Collection<Entry<K, V>>)compute.call(new IgniteCallable<Object>() {
+            @Override public Object call() throws Exception {
+                Collection res = new ArrayList();
+
+                for (Object o : cache())
+                    res.add(o);
+
+                return res;
+            }
+        });
+
+        return col.iterator();
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> Map<K, EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
+        CacheEntryProcessor<K, V, T> entryProcessor, Object... args) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteFuture<?> rebalance() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public CacheMetrics metrics() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public CacheMetrics metrics(ClusterGroup grp) {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public CacheMetricsMXBean mxBean() {
+        throw new UnsupportedOperationException("Method should be supported.");
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteClusterProcessProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteClusterProcessProxy.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteClusterProcessProxy.java
new file mode 100644
index 0000000..159c451
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteClusterProcessProxy.java
@@ -0,0 +1,320 @@
+/*
+ * 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.multijvm;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.internal.cluster.*;
+import org.apache.ignite.lang.*;
+import org.jetbrains.annotations.*;
+
+import java.io.*;
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * Proxy class for cluster at another JVM.
+ */
+@SuppressWarnings("TransientFieldInNonSerializableClass")
+public class IgniteClusterProcessProxy implements IgniteClusterEx {
+    /** Grid id. */
+    private final UUID gridId;
+
+    /** Compute. */
+    private final transient IgniteCompute compute;
+
+    /** */
+    private final IgniteProcessProxy proxy;
+
+    /**
+     * @param proxy Ignite Proxy.
+     */
+    public IgniteClusterProcessProxy(IgniteProcessProxy proxy) {
+        this.proxy = proxy;
+        gridId = proxy.getId();
+        compute = proxy.remoteCompute();
+    }
+
+    /**
+     * Returns cluster instance. Method to be called from closure at another JVM.
+     *
+     * @return Cache.
+     */
+    private IgniteClusterEx cluster() {
+        return (IgniteClusterEx)Ignition.ignite(gridId).cluster();
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroupEx forSubjectId(final UUID subjId) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forCacheNodes(@Nullable String cacheName, boolean affNodes, boolean nearNodes,
+        boolean clientNodes) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterNode localNode() {
+        return compute.call(new IgniteCallable<ClusterNode>() {
+            @Override public ClusterNode call() throws Exception {
+                return cluster().localNode();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forLocal() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> ConcurrentMap<K, V> nodeLocalMap() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean pingNode(UUID nodeId) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public long topologyVersion() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<ClusterNode> topology(long topVer) throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K> Map<ClusterNode, Collection<K>> mapKeysToNodes(@Nullable String cacheName,
+        @Nullable Collection<? extends K> keys) throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K> ClusterNode mapKeyToNode(@Nullable String cacheName, K key) throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<ClusterStartNodeResult> startNodes(File file, boolean restart, int timeout,
+        int maxConn) throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<ClusterStartNodeResult> startNodes(Collection<Map<String, Object>> hosts,
+        @Nullable Map<String, Object> dflts, boolean restart, int timeout, int maxConn) throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void stopNodes() throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void stopNodes(Collection<UUID> ids) throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void restartNodes() throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void restartNodes(Collection<UUID> ids) throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void resetMetrics() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCluster withAsync() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isAsync() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <R> IgniteFuture<R> future() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Ignite ignite() {
+        return proxy;
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forNodes(Collection<? extends ClusterNode> nodes) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forNode(ClusterNode node, ClusterNode... nodes) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forOthers(ClusterNode node, ClusterNode... nodes) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forOthers(ClusterGroup prj) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forNodeIds(Collection<UUID> ids) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forNodeId(UUID id, UUID... ids) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forPredicate(IgnitePredicate<ClusterNode> p) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forAttribute(String name, @Nullable Object val) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forServers() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forClients() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forCacheNodes(String cacheName) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forDataNodes(String cacheName) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forClientNodes(String cacheName) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forRemotes() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forHost(ClusterNode node) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forHost(String host, String... hosts) {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forDaemons() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forRandom() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forOldest() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup forYoungest() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<ClusterNode> nodes() {
+        return compute.call(new IgniteCallable<Collection<ClusterNode>>() {
+            @Override public Collection<ClusterNode> call() throws Exception {
+                return cluster().nodes();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterNode node(final UUID nid) {
+        return compute.call(new IgniteCallable<ClusterNode>() {
+            @Override public ClusterNode call() throws Exception {
+                return cluster().node(nid);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterNode node() {
+        return compute.call(new IgniteCallable<ClusterNode>() {
+            @Override public ClusterNode call() throws Exception {
+                return cluster().node();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<String> hostNames() {
+        return compute.call(new IgniteCallable<Collection<String>>() {
+            @Override public Collection<String> call() throws Exception {
+                return cluster().hostNames();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgnitePredicate<ClusterNode> predicate() {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterMetrics metrics() throws IgniteException {
+        throw new UnsupportedOperationException("Operation is not supported yet.");
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteEventsProcessProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteEventsProcessProxy.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteEventsProcessProxy.java
new file mode 100644
index 0000000..018aa8d
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteEventsProcessProxy.java
@@ -0,0 +1,148 @@
+/*
+ * 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.multijvm;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cluster.*;
+import org.apache.ignite.events.*;
+import org.apache.ignite.lang.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+
+/**
+ * Ignite events proxy for ignite instance at another JVM.
+ */
+@SuppressWarnings("TransientFieldInNonSerializableClass")
+public class IgniteEventsProcessProxy implements IgniteEvents {
+    /** Ignite proxy. */
+    private final transient IgniteProcessProxy igniteProxy;
+
+    /** Grid id. */
+    private final UUID gridId;
+
+    /**
+     * @param igniteProxy Ignite proxy.
+     */
+    public IgniteEventsProcessProxy(IgniteProcessProxy igniteProxy) {
+        this.igniteProxy = igniteProxy;
+
+        gridId = igniteProxy.getId();
+    }
+
+    /**
+     * @return Events instance.
+     */
+    private IgniteEvents events() {
+        return Ignition.ignite(gridId).events();
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterGroup clusterGroup() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T extends Event> List<T> remoteQuery(IgnitePredicate<T> p, long timeout,
+        @Nullable int... types) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T extends Event> UUID remoteListen(@Nullable IgniteBiPredicate<UUID, T> locLsnr,
+        @Nullable IgnitePredicate<T> rmtFilter, @Nullable int... types) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T extends Event> UUID remoteListen(int bufSize, long interval, boolean autoUnsubscribe,
+        @Nullable IgniteBiPredicate<UUID, T> locLsnr, @Nullable IgnitePredicate<T> rmtFilter,
+        @Nullable int... types) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void stopRemoteListen(UUID opId) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T extends Event> T waitForLocal(@Nullable IgnitePredicate<T> filter,
+        @Nullable int... types) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T extends Event> Collection<T> localQuery(IgnitePredicate<T> p, @Nullable int... types) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void recordLocal(Event evt) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void localListen(final IgnitePredicate<? extends Event> lsnr, final int... types) {
+        igniteProxy.remoteCompute().run(new IgniteRunnable() {
+            @Override public void run() {
+                events().localListen(lsnr, types);
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean stopLocalListen(IgnitePredicate<? extends Event> lsnr, @Nullable int... types) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void enableLocal(int... types) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void disableLocal(int... types) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public int[] enabledEvents() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isEnabled(int type) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteEvents withAsync() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isAsync() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <R> IgniteFuture<R> future() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteNodeRunner.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteNodeRunner.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteNodeRunner.java
new file mode 100644
index 0000000..2703d2b
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteNodeRunner.java
@@ -0,0 +1,184 @@
+/*
+ * 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.multijvm;
+
+import com.thoughtworks.xstream.*;
+import org.apache.ignite.*;
+import org.apache.ignite.configuration.*;
+import org.apache.ignite.internal.*;
+import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.util.*;
+import org.apache.ignite.internal.util.typedef.*;
+import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.marshaller.optimized.*;
+import org.apache.ignite.spi.discovery.tcp.*;
+import sun.jvmstat.monitor.*;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+
+/**
+ * Run ignite node.
+ */
+public class IgniteNodeRunner {
+    /** */
+    private static final String IGNITE_CONFIGURATION_FILE = System.getProperty("java.io.tmpdir") +
+        File.separator + "igniteConfiguration.tmp_";
+
+    /** */
+    private static volatile Ignite ignite;
+
+    /**
+     * Starts {@link Ignite} instance accorging to given arguments.
+     *
+     * @param args Arguments.
+     * @throws Exception If failed.
+     */
+    public static void main(String[] args) throws Exception {
+        X.println(GridJavaProcess.PID_MSG_PREFIX + U.jvmPid());
+
+        X.println("Starting Ignite Node... Args=" + Arrays.toString(args));
+
+        IgniteConfiguration cfg = readCfgFromFileAndDeleteFile(args[0]);
+
+        ignite = Ignition.start(cfg);
+    }
+
+    /**
+     * @return Ignite instance started at main.
+     */
+    public static IgniteEx startedInstance(){
+        return (IgniteEx)ignite;
+    }
+
+    /**
+     * @return <code>True</code> if there is ignite node started via {@link IgniteNodeRunner} at this JVM.
+     */
+    public static boolean hasStartedInstance() {
+        return ignite != null;
+    }
+
+    /**
+     * Stores {@link IgniteConfiguration} to file as xml.
+     *
+     * @param cfg Ignite Configuration.
+     * @return A name of file where the configuration was stored.
+     * @throws IOException If failed.
+     * @see #readCfgFromFileAndDeleteFile(String)
+     */
+    public static String storeToFile(IgniteConfiguration cfg) throws IOException {
+        String fileName = IGNITE_CONFIGURATION_FILE + cfg.getNodeId();
+
+        // Check marshaller configuration, because read configuration method expect specific marshaller.
+        if (cfg.getMarshaller() instanceof OptimizedMarshaller){
+            OptimizedMarshaller marsh = (OptimizedMarshaller)cfg.getMarshaller();
+
+            try {
+                Field isRequireFiled = marsh.getClass().getDeclaredField("requireSer");
+
+                isRequireFiled.setAccessible(true);
+
+                boolean isRequireSer = isRequireFiled.getBoolean(marsh);
+
+                if (isRequireSer)
+                    throw new UnsupportedOperationException("Unsupported marshaller configuration. " +
+                        "readCfgFromFileAndDeleteFile method expect " + OptimizedMarshaller.class.getSimpleName() +
+                        "with requireSerializeble flag in 'false'.");
+            }
+            catch (NoSuchFieldException|IllegalAccessException e) {
+                throw new IgniteException("Failed to check filed of " + OptimizedMarshaller.class.getSimpleName(), e);
+            }
+        }
+        else
+            throw new UnsupportedOperationException("Unsupported marshaller. " +
+                "readCfgFromFileAndDeleteFile method expect " + OptimizedMarshaller.class.getSimpleName());
+
+        try(OutputStream out = new BufferedOutputStream(new FileOutputStream(fileName))) {
+            cfg.setMBeanServer(null);
+            cfg.setMarshaller(null);
+            cfg.setDiscoverySpi(null);
+            cfg.setGridLogger(null);
+
+            new XStream().toXML(cfg, out);
+        }
+
+        return fileName;
+    }
+
+    /**
+     * Reads configuration from given file and delete the file after.
+     *
+     * @param fileName File name.
+     * @return Readed configuration.
+     * @throws IOException If failed.
+     * @see #storeToFile(IgniteConfiguration)
+     */
+    private static IgniteConfiguration readCfgFromFileAndDeleteFile(String fileName) throws IOException {
+        try(BufferedReader cfgReader = new BufferedReader(new FileReader(fileName))) {
+            IgniteConfiguration cfg = (IgniteConfiguration)new XStream().fromXML(cfgReader);
+
+            cfg.setMarshaller(new OptimizedMarshaller(false));
+
+            TcpDiscoverySpi disco = new TcpDiscoverySpi();
+            disco.setIpFinder(GridCacheAbstractFullApiSelfTest.LOCAL_IP_FINDER);
+            cfg.setDiscoverySpi(disco);
+
+            return cfg;
+        }
+        finally {
+            new File(fileName).delete();
+        }
+    }
+
+    /**
+     * Kill all Jvm runned by {#link IgniteNodeRunner}. Works based on jps command.
+     *
+     * @return List of killed process ids.
+     * @throws Exception If exception.
+     */
+    public static List<Integer> killAll() throws Exception{
+        MonitoredHost monitoredHost = MonitoredHost.getMonitoredHost(new HostIdentifier("localhost"));
+
+        Set<Integer> jvms = monitoredHost.activeVms();
+
+        List<Integer> res = new ArrayList<>();
+
+        for (Integer jvmId : jvms) {
+            try {
+                MonitoredVm vm = monitoredHost.getMonitoredVm(new VmIdentifier("//" + jvmId + "?mode=r"), 0);
+
+                if (IgniteNodeRunner.class.getName().equals(MonitoredVmUtil.mainClass(vm, true))) {
+                    Process killProc = U.isWindows() ?
+                        Runtime.getRuntime().exec(new String[] {"taskkill", "/pid", jvmId.toString(), "/f", "/t"}) :
+                        Runtime.getRuntime().exec(new String[] {"kill", "-9", jvmId.toString()});
+
+                    killProc.waitFor();
+
+                    res.add(jvmId);
+                }
+            }
+            catch (Exception e) {
+                // Print stack trace just for information.
+                X.printerrln("Could not kill IgniteNodeRunner java processes. Jvm pid = " + jvmId, e);
+            }
+        }
+
+        return res;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteProcessProxy.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteProcessProxy.java b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteProcessProxy.java
new file mode 100644
index 0000000..220424a
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/multijvm/IgniteProcessProxy.java
@@ -0,0 +1,571 @@
+/*
+ * 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.multijvm;
+
+import org.apache.ignite.*;
+import org.apache.ignite.cache.affinity.*;
+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.cluster.*;
+import org.apache.ignite.internal.processors.cache.*;
+import org.apache.ignite.internal.processors.hadoop.*;
+import org.apache.ignite.internal.util.*;
+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.lang.*;
+import org.apache.ignite.plugin.*;
+import org.jetbrains.annotations.*;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+/**
+ * Ignite proxy for ignite instance at another JVM.
+ */
+@SuppressWarnings("TransientFieldInNonSerializableClass")
+public class IgniteProcessProxy implements IgniteEx {
+    /** Grid proxies. */
+    private static final transient ConcurrentMap<String, IgniteProcessProxy> gridProxies = new ConcurrentHashMap<>();
+
+    /** Jvm process with ignite instance. */
+    private final transient GridJavaProcess proc;
+
+    /** Configuration. */
+    private final transient IgniteConfiguration cfg;
+
+    /** Local JVM grid. */
+    private final transient Ignite locJvmGrid;
+
+    /** Logger. */
+    private final transient IgniteLogger log;
+
+    /** Grid id. */
+    private final UUID id = UUID.randomUUID();
+
+    /**
+     * @param cfg Configuration.
+     * @param log Logger.
+     * @param locJvmGrid Local JVM grid.
+     */
+    public IgniteProcessProxy(final IgniteConfiguration cfg, final IgniteLogger log, final Ignite locJvmGrid)
+        throws Exception {
+        this.cfg = cfg;
+        this.locJvmGrid = locJvmGrid;
+        this.log = log.getLogger("jvm-" + id.toString().substring(0, id.toString().indexOf('-')));
+
+        String cfgFileName = IgniteNodeRunner.storeToFile(cfg.setNodeId(id));
+
+        List<String> jvmArgs = U.jvmArgs();
+
+        Collection<String> filteredJvmArgs = new ArrayList<>();
+
+        for (String arg : jvmArgs) {
+            if(!arg.toLowerCase().startsWith("-agentlib"))
+                filteredJvmArgs.add(arg);
+        }
+
+        final CountDownLatch rmtNodeStartedLatch = new CountDownLatch(1);
+
+        locJvmGrid.events().localListen(new NodeStartedListener(id, rmtNodeStartedLatch), EventType.EVT_NODE_JOINED);
+
+        proc = GridJavaProcess.exec(
+            IgniteNodeRunner.class,
+            cfgFileName, // Params.
+            this.log,
+            // Optional closure to be called each time wrapped process prints line to system.out or system.err.
+            new IgniteInClosure<String>() {
+                @Override public void apply(String s) {
+                    IgniteProcessProxy.this.log.info(s);
+                }
+            },
+            null,
+            filteredJvmArgs, // JVM Args.
+            System.getProperty("surefire.test.class.path")
+        );
+
+        assert rmtNodeStartedLatch.await(30, TimeUnit.SECONDS): "Remote node has not joined [id=" + id + ']';
+
+        IgniteProcessProxy prevVal = gridProxies.putIfAbsent(cfg.getGridName(), this);
+
+        if (prevVal != null) {
+            remoteCompute().run(new IgniteRunnable() {
+                @Override public void run() {
+                    G.stop(cfg.getGridName(), true);
+                }
+            });
+
+            throw new IllegalStateException("There was found instance assotiated with " + cfg.getGridName() +
+                ", instance= " + prevVal + ". New started node was stopped.");
+        }
+    }
+
+    /**
+     */
+    private static class NodeStartedListener extends IgnitePredicateX<Event> {
+        /** Id. */
+        private final UUID id;
+
+        /** Remote node started latch. */
+        private final CountDownLatch rmtNodeStartedLatch;
+
+        /**
+         * @param id Id.
+         * @param rmtNodeStartedLatch Remote node started latch.
+         */
+        NodeStartedListener(UUID id, CountDownLatch rmtNodeStartedLatch) {
+            this.id = id;
+            this.rmtNodeStartedLatch = rmtNodeStartedLatch;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean applyx(Event e) {
+            if (((DiscoveryEvent)e).eventNode().id().equals(id)) {
+                rmtNodeStartedLatch.countDown();
+
+                return false;
+            }
+
+            return true;
+        }
+    }
+
+    /**
+     * @param gridName Grid name.
+     * @return Instance by name or exception wiil be thrown.
+     */
+    public static IgniteProcessProxy ignite(String gridName) {
+        IgniteProcessProxy res = gridProxies.get(gridName);
+
+        if (res == null)
+            throw new IgniteIllegalStateException("Grid instance was not properly started " +
+                "or was already stopped: " + gridName + ". All known grid instances: " + gridProxies.keySet());
+
+        return res;
+    }
+
+    /**
+     * @param gridName Grid name.
+     * @param cancel Cacnel flag.
+     */
+    public static void stop(final String gridName, final boolean cancel) {
+        IgniteProcessProxy proxy = gridProxies.get(gridName);
+
+        if (proxy != null) {
+            proxy.remoteCompute().run(new IgniteRunnable() {
+                @Override public void run() {
+                    G.stop(gridName, cancel);
+                }
+            });
+
+            gridProxies.remove(gridName, proxy);
+        }
+    }
+
+    /**
+     * For usage in closures.
+     *
+     * @return Ignite instance.
+     */
+    private Ignite igniteById() {
+        return Ignition.ignite(id);
+    }
+
+    /**
+     * @param locNodeId ID of local node the requested grid instance is managing.
+     * @return An instance of named grid. This method never returns {@code null}.
+     * @throws IgniteIllegalStateException Thrown if grid was not properly initialized or grid instance was stopped or
+     * was not started.
+     */
+    public static Ignite ignite(UUID locNodeId) {
+        A.notNull(locNodeId, "locNodeId");
+
+        for (IgniteProcessProxy ignite : gridProxies.values()) {
+            if (ignite.getId().equals(locNodeId))
+                return ignite;
+        }
+
+        throw new IgniteIllegalStateException("Grid instance with given local node ID was not properly " +
+            "started or was stopped: " + locNodeId);
+    }
+
+    /**
+     * Kill all running processes.
+     */
+    public static void killAll() {
+        for (IgniteProcessProxy ignite : gridProxies.values()) {
+            try {
+                ignite.getProcess().kill();
+            }
+            catch (Exception e) {
+                U.error(ignite.log, "Killing failed.", e);
+            }
+        }
+
+        gridProxies.clear();
+    }
+
+    /**
+     * @return Local JVM grid instance.
+     */
+    public Ignite localJvmGrid() {
+        return locJvmGrid;
+    }
+
+    /**
+     * @return Grid id.
+     */
+    public UUID getId() {
+        return id;
+    }
+
+    /** {@inheritDoc} */
+    @Override public String name() {
+        return cfg.getGridName();
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteLogger log() {
+        return log;
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteConfiguration configuration() {
+        return cfg;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K extends GridCacheUtilityKey, V> IgniteInternalCache<K, V> utilityCache() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public <K, V> IgniteInternalCache<K, V> cachex(@Nullable String name) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public <K, V> IgniteInternalCache<K, V> cachex() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<IgniteInternalCache<?, ?>> cachesx(
+        @Nullable IgnitePredicate<? super IgniteInternalCache<?, ?>>... p) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean eventUserRecordable(int type) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean allEventsUserRecordable(int[] types) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isJmxRemoteEnabled() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isRestartEnabled() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public IgniteFileSystem igfsx(@Nullable String name) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Hadoop hadoop() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteClusterEx cluster() {
+        return new IgniteClusterProcessProxy(this);
+    }
+
+    /** {@inheritDoc} */
+    @Nullable @Override public String latestVersion() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ClusterNode localNode() {
+        return remoteCompute().call(new IgniteCallable<ClusterNode>() {
+            @Override public ClusterNode call() throws Exception {
+                return ((IgniteEx)Ignition.ignite(id)).localNode();
+            }
+        });
+    }
+
+    /** {@inheritDoc} */
+    @Override public GridKernalContext context() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCompute compute() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCompute compute(ClusterGroup grp) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteMessaging message() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteMessaging message(ClusterGroup grp) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteEvents events() {
+        return new IgniteEventsProcessProxy(this);
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteEvents events(ClusterGroup grp) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteServices services() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteServices services(ClusterGroup grp) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ExecutorService executorService() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public ExecutorService executorService(ClusterGroup grp) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteProductVersion version() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteScheduler scheduler() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> createCache(CacheConfiguration<K, V> cacheCfg) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> createCache(String cacheName) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> getOrCreateCache(CacheConfiguration<K, V> cacheCfg) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> getOrCreateCache(String cacheName) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> void addCacheConfiguration(CacheConfiguration<K, V> cacheCfg) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> createCache(CacheConfiguration<K, V> cacheCfg,
+        NearCacheConfiguration<K, V> nearCfg) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> getOrCreateCache(CacheConfiguration<K, V> cacheCfg,
+        NearCacheConfiguration<K, V> nearCfg) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override  public <K, V> IgniteCache<K, V> createNearCache(@Nullable String cacheName, NearCacheConfiguration<K, V> nearCfg) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> getOrCreateNearCache(@Nullable String cacheName,
+        NearCacheConfiguration<K, V> nearCfg) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void destroyCache(String cacheName) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteCache<K, V> cache(@Nullable final String name) {
+        return new IgniteCacheProcessProxy<>(name, this);
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteTransactions transactions() {
+        throw new UnsupportedOperationException("Transactions can't be supported automatically in multi JVM mode.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K, V> IgniteDataStreamer<K, V> dataStreamer(@Nullable String cacheName) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteFileSystem fileSystem(String name) {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public Collection<IgniteFileSystem> fileSystems() {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override  public IgniteAtomicSequence atomicSequence(String name, long initVal, boolean create) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteAtomicLong atomicLong(String name, long initVal, boolean create) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> IgniteAtomicReference<T> atomicReference(String name, @Nullable T initVal,
+        boolean create) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override  public <T, S> IgniteAtomicStamped<T, S> atomicStamped(String name, @Nullable T initVal, @Nullable S initStamp,
+        boolean create) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public IgniteCountDownLatch countDownLatch(String name, int cnt, boolean autoDel,
+        boolean create) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> IgniteQueue<T> queue(String name, int cap,
+        @Nullable CollectionConfiguration cfg) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T> IgniteSet<T> set(String name, @Nullable CollectionConfiguration cfg) throws IgniteException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public <T extends IgnitePlugin> T plugin(String name) throws PluginNotFoundException {
+        throw new UnsupportedOperationException("Operation isn't supported yet.");
+    }
+
+    /** {@inheritDoc} */
+    @Override public void close() throws IgniteException {
+        final CountDownLatch rmtNodeStoppedLatch = new CountDownLatch(1);
+
+        locJvmGrid.events().localListen(new IgnitePredicateX<Event>() {
+            @Override public boolean applyx(Event e) {
+                if (((DiscoveryEvent)e).eventNode().id().equals(id)) {
+                    rmtNodeStoppedLatch.countDown();
+
+                    return false;
+                }
+
+                return true;
+            }
+        }, EventType.EVT_NODE_LEFT, EventType.EVT_NODE_FAILED);
+
+        compute().run(new IgniteRunnable() {
+            @Override public void run() {
+                igniteById().close();
+            }
+        });
+
+        try {
+            assert U.await(rmtNodeStoppedLatch, 15, TimeUnit.SECONDS) : "NodeId=" + id;
+        }
+        catch (IgniteInterruptedCheckedException e) {
+            throw new IgniteException(e);
+        }
+
+        try {
+            getProcess().kill();
+        }
+        catch (Exception e) {
+            X.printerr("Could not kill process after close.", e);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override public <K> Affinity<K> affinity(String cacheName) {
+        return new AffinityProcessProxy<>(cacheName, this);
+    }
+
+    /**
+     * @return Jvm process in which grid node started.
+     */
+    public GridJavaProcess getProcess() {
+        return proc;
+    }
+
+    /**
+     * @return {@link IgniteCompute} instance to communicate with remote node.
+     */
+    public IgniteCompute remoteCompute() {
+        ClusterGroup grp = locJvmGrid.cluster().forNodeId(id);
+
+        if (grp.nodes().isEmpty())
+            throw new IllegalStateException("Could not found node with id=" + id + ".");
+
+        return locJvmGrid.compute(grp);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheFullApiMultiJvmSelfTestSuite.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheFullApiMultiJvmSelfTestSuite.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheFullApiMultiJvmSelfTestSuite.java
new file mode 100644
index 0000000..272305b
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheFullApiMultiJvmSelfTestSuite.java
@@ -0,0 +1,89 @@
+/*
+ * 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.testsuites;
+
+import junit.framework.*;
+import org.apache.ignite.internal.processors.cache.multijvm.*;
+
+/**
+ * Multi-JVM test suite.
+ */
+public class IgniteCacheFullApiMultiJvmSelfTestSuite extends TestSuite {
+    /**
+     * @return Multi-JVM tests suite.
+     * @throws Exception If failed.
+     */
+    public static TestSuite suite() throws Exception {
+        TestSuite suite = new TestSuite("Cache Full API Multi Jvm Test Suite");
+
+        // Multi-node.
+        suite.addTestSuite(GridCacheReplicatedMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheReplicatedMultiJvmP2PDisabledFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheReplicatedAtomicMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheReplicatedAtomicPrimaryWriteOrderMultiJvmFullApiSelfTest.class);
+
+        suite.addTestSuite(GridCachePartitionedMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedCopyOnReadDisabledMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicCopyOnReadDisabledMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicPrimaryWriteOrderMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedMultiJvmP2PDisabledFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicMultiJvmP2PDisabledFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicPrimaryWriteOrderMultiJvmP2PDisabledFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicNearEnabledMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicNearEnabledPrimaryWriteOrderMultiJvmFullApiSelfTest.class);
+
+        suite.addTestSuite(GridCachePartitionedNearDisabledMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedNearDisabledMultiJvmP2PDisabledFullApiSelfTest.class);
+
+        suite.addTestSuite(GridCacheNearOnlyMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheNearOnlyMultiJvmP2PDisabledFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheReplicatedNearOnlyMultiJvmFullApiSelfTest.class);
+
+        suite.addTestSuite(GridCacheAtomicClientOnlyMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicClientOnlyMultiJvmP2PDisabledFullApiSelfTest.class);
+
+        suite.addTestSuite(GridCacheAtomicNearOnlyMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicNearOnlyMultiJvmP2PDisabledFullApiSelfTest.class);
+
+        suite.addTestSuite(GridCachePartitionedFairAffinityMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedNearDisabledFairAffinityMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicFairAffinityMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicNearEnabledFairAffinityMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicPrimaryWriteOrderFairAffinityMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheNearOnlyFairAffinityMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicClientOnlyFairAffinityMultiJvmFullApiSelfTest.class);
+
+        // Multi-node with off-heap values.
+        suite.addTestSuite(GridCacheReplicatedOffHeapMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedOffHeapMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicOffHeapMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicPrimaryWrityOrderOffHeapMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedNearDisabledOffHeapMultiJvmFullApiSelfTest.class);
+
+        // Multi-node with off-heap tiered mode.
+        suite.addTestSuite(GridCacheReplicatedOffHeapTieredMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedOffHeapTieredMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicOffHeapTieredMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCacheAtomicPrimaryWrityOrderOffHeapTieredMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedNearDisabledOffHeapTieredMultiJvmFullApiSelfTest.class);
+        suite.addTestSuite(GridCachePartitionedNearDisabledAtomicOffHeapTieredMultiJvmFullApiSelfTest.class);
+
+        return suite;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/parent/pom.xml
----------------------------------------------------------------------
diff --git a/parent/pom.xml b/parent/pom.xml
index bfa9f62..dbaa330 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -720,5 +720,45 @@
                 </plugins>
             </build>
         </profile>
+
+        <profile>
+            <id>tools.jar-default</id>
+
+            <activation>
+                <file>
+                    <exists>${java.home}/../lib/tools.jar</exists>
+                </file>
+            </activation>
+
+            <dependencies>
+                <dependency>
+                    <groupId>com.sun</groupId>
+                    <artifactId>tools</artifactId>
+                    <version>1.4.2</version>
+                    <scope>system</scope>
+                    <systemPath>${java.home}/../lib/tools.jar</systemPath>
+                </dependency>
+            </dependencies>
+        </profile>
+
+        <profile>
+            <id>tools.jar-mac</id>
+
+            <activation>
+                <file>
+                    <exists>${java.home}/../Classes/classes.jar</exists>
+                </file>
+            </activation>
+
+            <dependencies>
+                <dependency>
+                    <groupId>com.sun</groupId>
+                    <artifactId>tools</artifactId>
+                    <version>1.4.2</version>
+                    <scope>system</scope>
+                    <systemPath>${java.home}/../Classes/classes.jar</systemPath>
+                </dependency>
+            </dependencies>
+        </profile>
     </profiles>
 </project>

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/8218fe6f/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index b47d34b..9d1b7d9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -678,7 +678,6 @@
             </build>
         </profile>
 
-
         <profile>
             <id>schema-import</id>
             <activation>