Java tutorial
/* * 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 java.io.Externalizable; import java.io.File; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectOutput; import java.io.ObjectOutputStream; import java.io.Serializable; import org.apache.commons.io.FileUtils; import org.apache.ignite.Ignition; import org.apache.ignite.binary.BinaryObjectException; import org.apache.ignite.binary.BinaryReader; import org.apache.ignite.binary.BinaryWriter; import org.apache.ignite.binary.Binarylizable; import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteEx; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.marshaller.jdk.JdkMarshaller; import org.apache.ignite.testframework.configvariations.VariationsTestsConfig; import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; /** * Common abstract test for Ignite tests based on configurations variations. */ public abstract class IgniteConfigVariationsAbstractTest extends GridCommonAbstractTest { /** */ protected static final int SERVER_NODE_IDX = 0; /** */ protected static final int CLIENT_NODE_IDX = 1; /** */ protected int testedNodeIdx; /** */ private static final File workDir = new File( U.getIgniteHome() + File.separator + "workOfConfigVariationsTests"); /** */ protected VariationsTestsConfig testsCfg; /** */ protected volatile DataMode dataMode = DataMode.PLANE_OBJECT; /** * @param testsCfg Tests configuration. */ public void setTestsConfiguration(VariationsTestsConfig testsCfg) { assert this.testsCfg == null : "Test config must be set only once [oldTestCfg=" + this.testsCfg + ", newTestCfg=" + testsCfg + "]"; this.testsCfg = testsCfg; } /** {@inheritDoc} */ @Override protected void beforeTestsStarted() throws Exception { assert testsCfg != null; FileUtils.deleteDirectory(workDir); info("Ignite's 'work' directory has been cleaned."); if (Ignition.allGrids().size() != testsCfg.gridCount()) { info("All nodes will be stopped, new " + testsCfg.gridCount() + " nodes will be started."); Ignition.stopAll(true); startGrids(testsCfg.gridCount()); for (int i = 0; i < testsCfg.gridCount(); i++) info("Grid " + i + ": " + grid(i).localNode().id()); } assert testsCfg.testedNodeIndex() >= 0 : "testedNodeIdx: " + testedNodeIdx; testedNodeIdx = testsCfg.testedNodeIndex(); if (testsCfg.withClients()) { for (int i = 0; i < gridCount(); i++) assertEquals("i: " + i, expectedClient(getTestIgniteInstanceName(i)), (boolean) grid(i).configuration().isClientMode()); } } /** * @param testGridName Name. * @return {@code True} if node is client should be client. */ protected boolean expectedClient(String testGridName) { return getTestIgniteInstanceName(CLIENT_NODE_IDX).equals(testGridName); } /** {@inheritDoc} */ @Override protected void afterTestsStopped() throws Exception { if (testsCfg.isStopNodes()) { info("Stopping all grids..."); stopAllGrids(); FileUtils.deleteDirectory(workDir); info("Ignite's 'work' directory has been cleaned."); memoryUsage(); System.gc(); memoryUsage(); } } /** * Prints memory usage. */ private void memoryUsage() { int mb = 1024 * 1024; Runtime runtime = Runtime.getRuntime(); info("##### Heap utilization statistics [MB] #####"); info("Used Memory (mb): " + (runtime.totalMemory() - runtime.freeMemory()) / mb); info("Free Memory (mb): " + runtime.freeMemory() / mb); info("Total Memory (mb): " + runtime.totalMemory() / mb); info("Max Memory (mb): " + runtime.maxMemory() / mb); } /** {@inheritDoc} */ @Override protected String testClassDescription() { assert testsCfg != null : "Tests should be run using test suite."; return super.testClassDescription() + '-' + testsCfg.description() + '-' + testsCfg.gridCount() + "-node(s)"; } /** {@inheritDoc} */ @Override protected String testDescription() { return super.testDescription() + '-' + testsCfg.description() + '-' + testsCfg.gridCount() + "-node(s)"; } /** {@inheritDoc} */ @Override protected IgniteConfiguration getConfiguration(String igniteInstanceName) throws Exception { IgniteConfiguration cfg = super.getConfiguration(igniteInstanceName); IgniteConfiguration resCfg = testsCfg.configurationFactory().getConfiguration(igniteInstanceName, cfg); resCfg.setWorkDirectory(workDir.getAbsolutePath()); if (testsCfg.withClients()) resCfg.setClientMode(expectedClient(igniteInstanceName)); return resCfg; } /** {@inheritDoc} */ protected final int gridCount() { return testsCfg.gridCount(); } /** * @return Count of clients. */ protected int clientsCount() { int cnt = 0; for (int i = 0; i < gridCount(); i++) { if (grid(i).configuration().isClientMode()) cnt++; } return cnt; } /** {@inheritDoc} */ @Override protected IgniteEx grid() { throw new UnsupportedOperationException( "Not supported, grid(int idx) or testedGrid() should be used instead."); } /** * @return Grid which should be tested. */ protected IgniteEx testedGrid() { return grid(testedNodeIdx); } /** * @return Tested grid in client mode or not. */ protected boolean isClientMode() { return grid(testedNodeIdx).configuration().isClientMode(); } /** * @return Count of server nodes at topology. */ protected int serversGridCount() { int cnt = 0; for (int i = 0; i < gridCount(); i++) { if (!grid(i).configuration().isClientMode()) cnt++; } return cnt; } /** * Runs in all data modes. * * @throws Exception If failed. */ protected void runInAllDataModes(TestRunnable call, DataMode... dataModes) throws Exception { if (F.isEmpty(dataModes)) dataModes = DataMode.values(); for (int i = 0; i < dataModes.length; i++) { dataMode = dataModes[i]; if (!isCompatible()) { info("Skipping test in data mode: " + dataMode); continue; } info("Running test in data mode: " + dataMode); if (i != 0) beforeTest(); try { call.run(); } catch (Throwable e) { e.printStackTrace(); throw e; } finally { if (i + 1 != DataMode.values().length) afterTest(); } } } /** * @param keyId Key Id. * @return Key. * @see #valueOf(Object) */ public Object key(int keyId) { return key(keyId, dataMode); } /** * @param valId Key Id. * @return Value. * @see #valueOf(Object) */ public Object value(int valId) { return value(valId, dataMode); } /** * @param keyId Key Id. * @param mode Mode. * @return Key. */ public static Object key(int keyId, DataMode mode) { if (mode == null) mode = DataMode.SERIALIZABLE; switch (mode) { case SERIALIZABLE: return new SerializableObject(keyId); case CUSTOM_SERIALIZABLE: return new CustomSerializableObject(keyId); case EXTERNALIZABLE: return new ExternalizableObject(keyId); case PLANE_OBJECT: return new PlaneObject(keyId); case BINARILIZABLE: return new BinarylizableObject(keyId); default: throw new IllegalArgumentException("mode: " + mode); } } /** * @param obj Key or value object * @return Value. */ public static int valueOf(Object obj) { assertNotNull(obj); if (obj instanceof TestObject) return ((TestObject) obj).value(); else throw new IllegalArgumentException("Unknown tested object type: " + obj); } /** * @param idx Index. * @param mode Mode. * @return Value. */ public static Object value(int idx, DataMode mode) { if (mode == null) mode = DataMode.SERIALIZABLE; switch (mode) { case SERIALIZABLE: return new SerializableObject(idx); case CUSTOM_SERIALIZABLE: return new CustomSerializableObject(idx); case EXTERNALIZABLE: return new ExternalizableObject(idx); case PLANE_OBJECT: return new PlaneObject(idx); case BINARILIZABLE: return new BinarylizableObject(idx); default: throw new IllegalArgumentException("mode: " + mode); } } /** * */ public static interface TestObject { /** * @return Value. */ public int value(); } /** * */ public static class PlaneObject implements TestObject { /** */ protected int val; /** */ protected String strVal; /** */ protected TestEnum enumVal; /** * Default constructor must be accessible for deserialize subclasses by JDK serialization API. */ PlaneObject() { // No-op. } /** * @param val Value. */ PlaneObject(int val) { this.val = val; strVal = "val" + val; TestEnum[] values = TestEnum.values(); enumVal = values[Math.abs(val) % values.length]; } /** {@inheritDoc} */ @Override public int value() { return val; } /** {@inheritDoc} */ @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof PlaneObject)) return false; PlaneObject val = (PlaneObject) o; return getClass().equals(o.getClass()) && this.val == val.val && enumVal == val.enumVal && strVal.equals(val.strVal); } /** {@inheritDoc} */ @Override public int hashCode() { return val; } /** {@inheritDoc} */ @Override public String toString() { return getClass().getSimpleName() + "[" + "val=" + val + ", strVal='" + strVal + '\'' + ", enumVal=" + enumVal + ']'; } } /** * */ protected static class SerializableObject implements Serializable, TestObject { /** */ private static final long serialVersionUID = 0; /** */ protected int val; /** */ protected String strVal; /** */ protected TestEnum enumVal; /** * Default constructor. */ public SerializableObject() { // No-op. } /** * @param val Value. */ public SerializableObject(int val) { this.val = val; strVal = "val" + val; TestEnum[] values = TestEnum.values(); enumVal = values[Math.abs(val) % values.length]; } /** {@inheritDoc} */ @Override public int value() { return val; } /** {@inheritDoc} */ @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof SerializableObject)) return false; SerializableObject val = (SerializableObject) o; return getClass().equals(o.getClass()) && this.val == val.val && enumVal == val.enumVal && strVal.equals(val.strVal); } /** {@inheritDoc} */ @Override public int hashCode() { return val; } /** {@inheritDoc} */ @Override public String toString() { return getClass().getSimpleName() + "[" + "val=" + val + ", strVal='" + strVal + '\'' + ", enumVal=" + enumVal + ']'; } } /** * */ protected static class CustomSerializableObject extends PlaneObject implements Serializable { /** */ private static final long serialVersionUID = 0; /** * Default constructor. */ public CustomSerializableObject() { // No-op. } /** * @param val Value. */ public CustomSerializableObject(int val) { super(val); } /** * Custom serialization of superclass because {@link PlaneObject} is non-serializable. * * @param out output stream. * @throws IOException if de-serialization failed. */ private void writeObject(ObjectOutputStream out) throws IOException { out.writeInt(val); out.writeObject(strVal); out.writeObject(enumVal); } /** * Custom deserialization of superclass because {@link PlaneObject} is non-serializable. * * @param in input stream * @throws IOException if de-serialization failed. * @throws ClassNotFoundException if de-serialization failed. */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { val = in.readInt(); strVal = (String) in.readObject(); enumVal = (TestEnum) in.readObject(); } } /** * */ private static class ExternalizableObject extends PlaneObject implements Externalizable { /** */ private static final long serialVersionUID = 0; /** * Default constructor. */ public ExternalizableObject() { super(-1); } /** * @param val Value. */ ExternalizableObject(int val) { super(val); } /** {@inheritDoc} */ @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(val); out.writeObject(strVal); out.writeObject(enumVal); } /** {@inheritDoc} */ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { val = in.readInt(); strVal = (String) in.readObject(); enumVal = (TestEnum) in.readObject(); } } /** * */ public static class BinarylizableObject extends PlaneObject implements Binarylizable { /** * Default constructor. */ public BinarylizableObject() { super(-1); } /** * @param val Value. */ public BinarylizableObject(int val) { super(val); } /** {@inheritDoc} */ @Override public void writeBinary(BinaryWriter writer) throws BinaryObjectException { writer.writeInt("val", val); writer.writeString("strVal", strVal); writer.writeEnum("enumVal", enumVal); } /** {@inheritDoc} */ @Override public void readBinary(BinaryReader reader) throws BinaryObjectException { val = reader.readInt("val"); strVal = reader.readString("strVal"); enumVal = reader.readEnum("enumVal"); } } /** * Data mode. */ public enum DataMode { /** Serializable objects. */ SERIALIZABLE, /** Serializable objects with custom serialization. */ CUSTOM_SERIALIZABLE, /** Externalizable objects. */ EXTERNALIZABLE, /** Objects without Serializable and Externalizable. */ PLANE_OBJECT, /** Binarylizable objects. Compatible only with binary marshaller */ BINARILIZABLE } /** * */ private enum TestEnum { /** */ TEST_VALUE_1, /** */ TEST_VALUE_2, /** */ TEST_VALUE_3 } /** * */ public interface TestRunnable { /** * @throws Exception If failed. */ void run() throws Exception; } /** * Check test compatibility with current data mode * * @return {@code True} if compatible. * @throws Exception If failed. */ protected boolean isCompatible() throws Exception { switch (dataMode) { case BINARILIZABLE: case PLANE_OBJECT: return !(getConfiguration().getMarshaller() instanceof JdkMarshaller); } return false; } }