diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/DefaultMessageTaskFactoryProvider.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/DefaultMessageTaskFactoryProvider.java index 122c1efa1f35..463df54f1b40 100755 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/DefaultMessageTaskFactoryProvider.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/DefaultMessageTaskFactoryProvider.java @@ -240,6 +240,7 @@ import com.hazelcast.client.impl.protocol.codec.MapProjectCodec; import com.hazelcast.client.impl.protocol.codec.MapProjectWithPredicateCodec; import com.hazelcast.client.impl.protocol.codec.MapPutAllCodec; +import com.hazelcast.client.impl.protocol.codec.MapPutAllWithMetadataCodec; import com.hazelcast.client.impl.protocol.codec.MapPutCodec; import com.hazelcast.client.impl.protocol.codec.MapPutIfAbsentCodec; import com.hazelcast.client.impl.protocol.codec.MapPutIfAbsentWithMaxIdleCodec; @@ -624,6 +625,7 @@ import com.hazelcast.client.impl.protocol.task.map.MapProjectionWithPredicateMessageTask; import com.hazelcast.client.impl.protocol.task.map.MapPublisherCreateMessageTask; import com.hazelcast.client.impl.protocol.task.map.MapPublisherCreateWithValueMessageTask; +import com.hazelcast.client.impl.protocol.task.map.MapPutAllWithMetadataMessageTask; import com.hazelcast.client.impl.protocol.task.map.MapPutAllMessageTask; import com.hazelcast.client.impl.protocol.task.map.MapPutIfAbsentMessageTask; import com.hazelcast.client.impl.protocol.task.map.MapPutIfAbsentWithMaxIdleMessageTask; @@ -1488,6 +1490,8 @@ private void initializeMapTaskFactories() { (cm, con) -> new MapPutIfAbsentWithMaxIdleMessageTask(cm, node, con)); factories.put(MapPutTransientWithMaxIdleCodec.REQUEST_MESSAGE_TYPE, (cm, con) -> new MapPutTransientWithMaxIdleMessageTask(cm, node, con)); + factories.put(MapPutAllWithMetadataCodec.REQUEST_MESSAGE_TYPE, + (cm, con) -> new MapPutAllWithMetadataMessageTask(cm, node, con)); } private void initializeGeneralTaskFactories() { diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/MapPutAllWithMetadataCodec.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/MapPutAllWithMetadataCodec.java new file mode 100644 index 000000000000..b528fdc38618 --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/MapPutAllWithMetadataCodec.java @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved. + * + * Licensed 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 com.hazelcast.client.impl.protocol.codec; + +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.Generated; +import com.hazelcast.client.impl.protocol.codec.builtin.*; +import com.hazelcast.client.impl.protocol.codec.custom.*; + +import javax.annotation.Nullable; + +import static com.hazelcast.client.impl.protocol.ClientMessage.*; +import static com.hazelcast.client.impl.protocol.codec.builtin.FixedSizeTypesCodec.*; + +/* + * This file is auto-generated by the Hazelcast Client Protocol Code Generator. + * To change this file, edit the templates or the protocol + * definitions on the https://github.com/hazelcast/hazelcast-client-protocol + * and regenerate it. + */ + +/** + * Copies all of the mappings from the specified entry list to this map, including metadata. + * The implementation uses MergeOperation with PassThroughMergePolicy, so the effect of + * this call is equivalent to synchronizing given entries using WAN replication. + * Please note that all the keys in the request should belong to the partition id to which this request is being sent, all keys + * matching to a different partition id shall be ignored. The API implementation using this request may need to send multiple + * of these request messages for filling a request for a key set if the keys belong to different partitions. + */ +@Generated("a8d1d03ec3de96de55d76858ff81db9a") +public final class MapPutAllWithMetadataCodec { + //hex: 0x014900 + public static final int REQUEST_MESSAGE_TYPE = 84224; + //hex: 0x014901 + public static final int RESPONSE_MESSAGE_TYPE = 84225; + private static final int REQUEST_INITIAL_FRAME_SIZE = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int RESPONSE_INITIAL_FRAME_SIZE = RESPONSE_BACKUP_ACKS_FIELD_OFFSET + BYTE_SIZE_IN_BYTES; + + private MapPutAllWithMetadataCodec() { + } + + @edu.umd.cs.findbugs.annotations.SuppressFBWarnings({"URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD"}) + public static class RequestParameters { + + /** + * name of map + */ + public java.lang.String name; + + /** + * entries with metadata + */ + public java.util.List> entries; + } + + public static ClientMessage encodeRequest(java.lang.String name, java.util.Collection> entries) { + ClientMessage clientMessage = ClientMessage.createForEncode(); + clientMessage.setContainsSerializedDataInRequest(true); + clientMessage.setRetryable(false); + clientMessage.setOperationName("Map.PutAllWithMetadata"); + ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[REQUEST_INITIAL_FRAME_SIZE], UNFRAGMENTED_MESSAGE); + encodeInt(initialFrame.content, TYPE_FIELD_OFFSET, REQUEST_MESSAGE_TYPE); + encodeInt(initialFrame.content, PARTITION_ID_FIELD_OFFSET, -1); + clientMessage.add(initialFrame); + StringCodec.encode(clientMessage, name); + ListMultiFrameCodec.encode(clientMessage, entries, SimpleEntryViewCodec::encode); + return clientMessage; + } + + public static MapPutAllWithMetadataCodec.RequestParameters decodeRequest(ClientMessage clientMessage) { + ClientMessage.ForwardFrameIterator iterator = clientMessage.frameIterator(); + RequestParameters request = new RequestParameters(); + //empty initial frame + iterator.next(); + request.name = StringCodec.decode(iterator); + request.entries = ListMultiFrameCodec.decode(iterator, SimpleEntryViewCodec::decode); + return request; + } + + public static ClientMessage encodeResponse() { + ClientMessage clientMessage = ClientMessage.createForEncode(); + ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[RESPONSE_INITIAL_FRAME_SIZE], UNFRAGMENTED_MESSAGE); + encodeInt(initialFrame.content, TYPE_FIELD_OFFSET, RESPONSE_MESSAGE_TYPE); + clientMessage.add(initialFrame); + + return clientMessage; + } +} diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/map/MapPutAllWithMetadataMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/map/MapPutAllWithMetadataMessageTask.java new file mode 100644 index 000000000000..8521b5742c0b --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/map/MapPutAllWithMetadataMessageTask.java @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved. + * + * Licensed 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 com.hazelcast.client.impl.protocol.task.map; + +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.codec.MapPutAllWithMetadataCodec; +import com.hazelcast.instance.impl.Node; +import com.hazelcast.internal.nio.Connection; +import com.hazelcast.internal.serialization.Data; +import com.hazelcast.internal.serialization.SerializationService; +import com.hazelcast.internal.util.Timer; +import com.hazelcast.map.impl.MapContainer; +import com.hazelcast.map.impl.MapService; +import com.hazelcast.map.impl.SimpleEntryView; +import com.hazelcast.map.impl.operation.MergeOperation; +import com.hazelcast.security.permission.ActionConstants; +import com.hazelcast.security.permission.MapPermission; +import com.hazelcast.spi.impl.operationservice.Operation; +import com.hazelcast.spi.merge.PassThroughMergePolicy; +import com.hazelcast.spi.merge.SplitBrainMergePolicy; +import com.hazelcast.spi.merge.SplitBrainMergeTypes.MapMergeTypes; + +import java.security.Permission; +import java.util.ArrayList; +import java.util.List; + +import static com.hazelcast.spi.impl.merge.MergingValueFactory.createMergingEntry; + +public class MapPutAllWithMetadataMessageTask + extends AbstractMapPartitionMessageTask { + + private volatile long startTimeNanos; + + public MapPutAllWithMetadataMessageTask(ClientMessage clientMessage, Node node, Connection connection) { + super(clientMessage, node, connection); + } + + @Override + protected Operation prepareOperation() { + SerializationService ss = nodeEngine.getSerializationService(); + + List> mergingEntries = new ArrayList<>(); + for (SimpleEntryView entry : parameters.entries) { + mergingEntries.add(createMergingEntry(ss, entry)); + } + + SplitBrainMergePolicy mergePolicy = nodeEngine.getSplitBrainMergePolicyProvider() + .getMergePolicy(PassThroughMergePolicy.class.getName()); + + return new MergeOperation(parameters.name, mergingEntries, mergePolicy, true); + } + + @Override + protected MapPutAllWithMetadataCodec.RequestParameters decodeClientMessage(ClientMessage clientMessage) { + return MapPutAllWithMetadataCodec.decodeRequest(clientMessage); + } + + @Override + protected ClientMessage encodeResponse(Object response) { + return MapPutAllWithMetadataCodec.encodeResponse(); + } + + @Override + public String getServiceName() { + return MapService.SERVICE_NAME; + } + + @Override + protected void beforeProcess() { + startTimeNanos = Timer.nanos(); + } + + @Override + protected Object processResponseBeforeSending(Object response) { + MapService mapService = getService(MapService.SERVICE_NAME); + MapContainer mapContainer = mapService.getMapServiceContext().getMapContainer(parameters.name); + if (mapContainer.getMapConfig().isStatisticsEnabled()) { + mapService.getMapServiceContext().getLocalMapStatsProvider().getLocalMapStatsImpl(parameters.name) + .incrementPutLatencyNanos(parameters.entries.size(), + Timer.nanosElapsed(startTimeNanos)); + } + return response; + } + + @Override + public Permission getRequiredPermission() { + return new MapPermission(parameters.name, ActionConstants.ACTION_PUT); + } + + @Override + public String getDistributedObjectName() { + return parameters.name; + } + + @Override + public String getMethodName() { + return "putAllWithMetadata"; + } + + @Override + public Object[] getParameters() { + List> entries = new ArrayList<>(parameters.entries); + return new Object[]{entries}; + } +} diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/ClientMapProxy.java b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/ClientMapProxy.java index c399e3d8d375..f6472128bdeb 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/ClientMapProxy.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/ClientMapProxy.java @@ -61,6 +61,7 @@ import com.hazelcast.client.impl.protocol.codec.MapProjectCodec; import com.hazelcast.client.impl.protocol.codec.MapProjectWithPredicateCodec; import com.hazelcast.client.impl.protocol.codec.MapPutAllCodec; +import com.hazelcast.client.impl.protocol.codec.MapPutAllWithMetadataCodec; import com.hazelcast.client.impl.protocol.codec.MapPutCodec; import com.hazelcast.client.impl.protocol.codec.MapPutIfAbsentCodec; import com.hazelcast.client.impl.protocol.codec.MapPutIfAbsentWithMaxIdleCodec; @@ -160,6 +161,7 @@ import java.util.Map; import java.util.Set; import java.util.UUID; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; @@ -185,6 +187,7 @@ import static java.lang.Thread.currentThread; import static java.util.Collections.emptyMap; import static java.util.concurrent.TimeUnit.MILLISECONDS; +import static java.util.stream.Collectors.groupingBy; /** * Proxy implementation of {@link IMap}. @@ -1670,6 +1673,76 @@ private void putAllInternal(@Nonnull Map map, protected void finalizePutAll(Map map, Map>> entryMap) { } + public CompletableFuture putAllWithMetadataAsync(@Nonnull Collection> entries) { + checkNotNull(entries, "Null argument entries is not allowed"); + ClientPartitionService partitionService = getContext().getPartitionService(); + + Map>> entriesByPartition = + entries.stream() + .map(e -> { + checkNotNull(e.getKey(), NULL_KEY_IS_NOT_ALLOWED); + checkNotNull(e.getValue(), NULL_VALUE_IS_NOT_ALLOWED); + + Data keyData = toData(e.getKey()); + if (e instanceof SimpleEntryView + && e.getKey() instanceof Data + && e.getValue() instanceof Data + ) { + return (SimpleEntryView) e; + } else { + return new SimpleEntryView<>(keyData, toData(e.getValue())) + .withCost(e.getCost()) + .withCreationTime(e.getCreationTime()) + .withExpirationTime(e.getExpirationTime()) + .withHits(e.getHits()) + .withLastAccessTime(e.getLastAccessTime()) + .withLastStoredTime(e.getLastStoredTime()) + .withLastUpdateTime(e.getLastUpdateTime()) + .withVersion(e.getVersion()) + .withTtl(e.getTtl()) + .withMaxIdle(e.getMaxIdle()); + } + }) + .collect(groupingBy( + (SimpleEntryView e) -> partitionService.getPartitionId(e.getKey()) + )); + + AtomicInteger counter = new AtomicInteger(entriesByPartition.size()); + InternalCompletableFuture resultFuture = new InternalCompletableFuture<>(); + if (counter.get() == 0) { + resultFuture.complete(null); + } + for (Entry>> entry : entriesByPartition.entrySet()) { + Integer partitionId = entry.getKey(); + ClientMessage request = MapPutAllWithMetadataCodec.encodeRequest(name, entry.getValue()); + ClientInvocationFuture future = new ClientInvocation(getClient(), request, getName(), partitionId) + .invoke(); + + future.whenCompleteAsync((clientMessage, throwable) -> { + if (throwable != null) { + resultFuture.completeExceptionally(throwable); + return; + } + if (counter.decrementAndGet() == 0) { + finalizePutAll( + entries, + entriesByPartition + ); + if (!resultFuture.isDone()) { + resultFuture.complete(null); + } + } + }, ConcurrencyUtil.getDefaultAsyncExecutor()); + } + + return resultFuture; + } + + protected void finalizePutAll( + Collection> entries, Map>> entryMap) { + } + @Override public void clear() { ClientMessage request = MapClearCodec.encodeRequest(name); diff --git a/hazelcast/src/main/java/com/hazelcast/client/map/impl/nearcache/NearCachedClientMapProxy.java b/hazelcast/src/main/java/com/hazelcast/client/map/impl/nearcache/NearCachedClientMapProxy.java index d706966882fa..405a5b564f6e 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/map/impl/nearcache/NearCachedClientMapProxy.java +++ b/hazelcast/src/main/java/com/hazelcast/client/map/impl/nearcache/NearCachedClientMapProxy.java @@ -27,6 +27,7 @@ import com.hazelcast.client.impl.spi.impl.ClientInvocationFuture; import com.hazelcast.client.impl.spi.impl.ListenerMessageCodec; import com.hazelcast.config.NearCacheConfig; +import com.hazelcast.core.EntryView; import com.hazelcast.internal.adapter.IMapDataStructureAdapter; import com.hazelcast.internal.monitor.impl.LocalMapStatsImpl; import com.hazelcast.internal.nearcache.NearCache; @@ -39,6 +40,7 @@ import com.hazelcast.logging.ILogger; import com.hazelcast.map.EntryProcessor; import com.hazelcast.map.LocalMapStats; +import com.hazelcast.map.impl.SimpleEntryView; import com.hazelcast.query.Predicate; import com.hazelcast.spi.impl.InternalCompletableFuture; import com.hazelcast.core.ReadOnly; @@ -560,6 +562,24 @@ protected void finalizePutAll(Map map, Map> entries, + Map>> entriesByPartition + ) { + if (serializeKeys) { + for (List> partitionEntries : entriesByPartition.values()) { + for (EntryView entry : partitionEntries) { + invalidateNearCache(entry.getKey()); + } + } + } else { + for (EntryView entry : entries) { + invalidateNearCache(entry.getKey()); + } + } + } + @Override public void clear() { nearCache.clear(); diff --git a/hazelcast/src/test/java/com/hazelcast/client/map/ClientMapTest.java b/hazelcast/src/test/java/com/hazelcast/client/map/ClientMapTest.java index 07a374a21ca2..411179661dfb 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/map/ClientMapTest.java +++ b/hazelcast/src/test/java/com/hazelcast/client/map/ClientMapTest.java @@ -21,16 +21,19 @@ import com.hazelcast.client.map.helpers.GenericEvent; import com.hazelcast.client.test.TestHazelcastFactory; import com.hazelcast.config.Config; +import com.hazelcast.config.MapConfig; import com.hazelcast.config.MapStoreConfig; import com.hazelcast.core.EntryAdapter; import com.hazelcast.core.EntryEvent; import com.hazelcast.core.EntryListener; +import com.hazelcast.core.EntryView; import com.hazelcast.core.HazelcastInstance; import com.hazelcast.map.EntryProcessor; import com.hazelcast.map.IMap; import com.hazelcast.map.LocalMapStats; import com.hazelcast.map.MapEvent; import com.hazelcast.map.MapStoreAdapter; +import com.hazelcast.map.impl.SimpleEntryView; import com.hazelcast.map.listener.EntryAddedListener; import com.hazelcast.map.listener.EntryExpiredListener; import com.hazelcast.multimap.MultiMap; @@ -50,6 +53,7 @@ import com.hazelcast.test.HazelcastTestSupport; import com.hazelcast.test.annotation.ParallelJVMTest; import com.hazelcast.test.annotation.QuickTest; +import org.assertj.core.api.SoftAssertions; import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -57,18 +61,27 @@ import org.junit.runner.RunWith; import java.io.Serializable; +import java.time.Duration; +import java.time.Instant; +import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; +import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.CountDownLatch; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; +import static java.util.Collections.emptyList; import static java.util.Collections.emptyMap; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.entry; +import static org.assertj.core.util.Lists.newArrayList; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -380,6 +393,79 @@ public void testAsyncPutAll() { assertEquals(tmpMap, new HashMap<>(map)); } + @Test + public void testPutAllWithMetadata() { + String mapName = randomMapName(); + client.getConfig().addMapConfig(new MapConfig(mapName).setPerEntryStatsEnabled(true)); + IMap map = client.getMap(mapName); + ClientMapProxy mapProxy = (ClientMapProxy) map; + + // The times are in milliseconds, but have second precision + long now = Duration.ofSeconds(Instant.now().getEpochSecond()).toMillis(); + SimpleEntryView entryView = new SimpleEntryView() + .withKey("key") + .withValue("value") + .withCreationTime(now) + .withHits(42) + .withExpirationTime(now + Duration.ofMinutes(1).toMillis()) + .withLastAccessTime(now) + .withLastUpdateTime(now) + .withVersion(5) + .withTtl(60_000) + .withMaxIdle(60_000); + + CompletableFuture future = mapProxy.putAllWithMetadataAsync(newArrayList(entryView)); + assertEqualsEventually(() -> future.isDone(), true); + EntryView actual = map.getEntryView("key"); + + SoftAssertions sa = new SoftAssertions(); + + sa.assertThat(actual.getCreationTime()).describedAs("creationTime").isEqualTo(entryView.getCreationTime()); + sa.assertThat(actual.getExpirationTime()).describedAs("expirationTime").isEqualTo(entryView.getExpirationTime()); + sa.assertThat(actual.getLastAccessTime()).describedAs("lastAccessTime").isEqualTo(entryView.getLastAccessTime()); + sa.assertThat(actual.getLastUpdateTime()).describedAs("lastUpdateTime").isEqualTo(entryView.getLastUpdateTime()); + sa.assertThat(actual.getTtl()).describedAs("ttl").isEqualTo(entryView.getTtl()); + sa.assertThat(actual.getMaxIdle()).describedAs("maxIdle").isEqualTo(entryView.getMaxIdle()); + + sa.assertAll(); + + assertThat((Map) map).hasSize(1); + } + + @Test + public void testWithMetadataMultipleEntries() { + String mapName = randomMapName(); + client.getConfig().addMapConfig(new MapConfig(mapName).setPerEntryStatsEnabled(true)); + IMap map = client.getMap(mapName); + ClientMapProxy mapProxy = (ClientMapProxy) map; + + List> entries = new ArrayList<>(); + for (int i = 0; i < 1000; i++) { + entries.add(new SimpleEntryView<>("key-" + i, "value-" + i)); + } + + CompletableFuture future = mapProxy.putAllWithMetadataAsync(entries); + assertEqualsEventually(() -> future.isDone(), true); + + assertThat((Map) map).hasSize(1000); + for (int i = 0; i < 1000; i++) { + assertThat((Map) map).contains(entry("key-" + i, "value-" + i)); + } + } + + @Test + public void testPutAllWithMetadataEmpty() { + String mapName = randomMapName(); + client.getConfig().addMapConfig(new MapConfig(mapName).setPerEntryStatsEnabled(true)); + IMap map = client.getMap(mapName); + ClientMapProxy mapProxy = (ClientMapProxy) map; + + CompletableFuture future = mapProxy.putAllWithMetadataAsync(emptyList()); + assertEqualsEventually(() -> future.isDone(), true); + + assertThat((Map) map).isEmpty(); + } + @Test public void testTryPutRemove() { final IMap map = createMap(); diff --git a/hazelcast/src/test/java/com/hazelcast/client/map/impl/nearcache/ClientMapNearCacheInvalidationTest.java b/hazelcast/src/test/java/com/hazelcast/client/map/impl/nearcache/ClientMapNearCacheInvalidationTest.java index eed46eeee545..0d80a5e416fb 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/map/impl/nearcache/ClientMapNearCacheInvalidationTest.java +++ b/hazelcast/src/test/java/com/hazelcast/client/map/impl/nearcache/ClientMapNearCacheInvalidationTest.java @@ -17,10 +17,12 @@ package com.hazelcast.client.map.impl.nearcache; import com.hazelcast.client.config.ClientConfig; +import com.hazelcast.client.impl.proxy.ClientMapProxy; import com.hazelcast.client.test.ClientTestSupport; import com.hazelcast.client.test.TestHazelcastFactory; import com.hazelcast.config.Config; import com.hazelcast.config.NearCacheConfig; +import com.hazelcast.core.EntryView; import com.hazelcast.core.HazelcastInstance; import com.hazelcast.internal.nearcache.NearCache; import com.hazelcast.map.IMap; @@ -36,6 +38,10 @@ import org.junit.experimental.categories.Category; import org.junit.runner.RunWith; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import java.util.Set; import java.util.function.BiConsumer; import java.util.stream.Collectors; @@ -166,6 +172,78 @@ public void testMapClear_shouldClearNearCaches_onOwnerAndBackupNodes() { assertNearCacheSizeEventually(clientMap, 0); } + @Test + public void testPutAllWithMetadata_shouldClearNearCaches_onOwnerAndBackupNodes() { + Config config = getConfig(); + configureBatching(config, 10, 1); + + ClientConfig clientConfig = getClientConfig(mapName); + + HazelcastInstance server = factory.newHazelcastInstance(config); + factory.newHazelcastInstance(config); + + HazelcastInstance client = factory.newHazelcastClient(clientConfig); + makeSureConnectedToServers(client, 2); + + IMap serverMap = server.getMap(mapName); + IMap clientMap = client.getMap(mapName); + + int size = 1000; + + // fill serverMap + for (int i = 0; i < size; i++) { + serverMap.put(i, i); + } + + List> entries = new ArrayList<>(size); + + // fill Near Cache on client + for (int i = 0; i < size; i++) { + clientMap.get(i); + entries.add(clientMap.getEntryView(i)); + } + + ((ClientMapProxy) clientMap).putAllWithMetadataAsync(entries); + + assertNearCacheSizeEventually(clientMap, 0); + } + + @Test + public void testPutAll_shouldClearNearCaches_onOwnerAndBackupNodes() { + Config config = getConfig(); + configureBatching(config, 10, 1); + + ClientConfig clientConfig = getClientConfig(mapName); + + HazelcastInstance server = factory.newHazelcastInstance(config); + factory.newHazelcastInstance(config); + + HazelcastInstance client = factory.newHazelcastClient(clientConfig); + makeSureConnectedToServers(client, 2); + + IMap serverMap = server.getMap(mapName); + IMap clientMap = client.getMap(mapName); + + int size = 1000; + + // fill serverMap + for (int i = 0; i < size; i++) { + serverMap.put(i, i); + } + + Map entries = new HashMap<>(size); + + // fill Near Cache on client + for (int i = 0; i < size; i++) { + clientMap.get(i); + entries.put(i, i); + } + + clientMap.putAll(entries); + + assertNearCacheSizeEventually(clientMap, 0); + } + @Test public void testMapSubmitToKey_withReadOnlyProcessor_noInvalidations() { verifyNoInvalidationsWith((map, size) -> { diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_7.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_7.java new file mode 100644 index 000000000000..166abd9e53d6 --- /dev/null +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_7.java @@ -0,0 +1,7269 @@ +/* + * Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved. + * + * Licensed 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 com.hazelcast.client.protocol.compatibility; + +import com.hazelcast.client.HazelcastClientUtil; +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.ClientMessageReader; +import com.hazelcast.client.impl.protocol.codec.*; +import com.hazelcast.test.HazelcastParallelClassRunner; +import com.hazelcast.test.annotation.ParallelJVMTest; +import com.hazelcast.test.annotation.QuickTest; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static com.hazelcast.client.impl.protocol.ClientMessage.IS_FINAL_FLAG; +import static com.hazelcast.client.protocol.compatibility.ReferenceObjects.*; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.fail; + +@RunWith(HazelcastParallelClassRunner.class) +@Category({QuickTest.class, ParallelJVMTest.class}) +public class ClientCompatibilityNullTest_2_7 { + private final List clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.7.protocol.compatibility.null.binary").getFile()); + InputStream inputStream = new FileInputStream(file); + byte[] data = new byte[(int) file.length()]; + inputStream.read(data); + ByteBuffer buffer = ByteBuffer.wrap(data); + ClientMessageReader reader = new ClientMessageReader(0); + while (reader.readFrom(buffer, true)) { + clientMessages.add(reader.getClientMessage()); + reader.reset(); + } + } + + @Test + public void test_ClientAuthenticationCodec_encodeRequest() { + int fileClientMessageIndex = 0; + ClientMessage encoded = ClientAuthenticationCodec.encodeRequest(aString, null, null, null, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAuthenticationCodec_decodeResponse() { + int fileClientMessageIndex = 1; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCodec.ResponseParameters parameters = ClientAuthenticationCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(null, parameters.address)); + assertTrue(isEqual(null, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + } + + @Test + public void test_ClientAuthenticationCustomCodec_encodeRequest() { + int fileClientMessageIndex = 2; + ClientMessage encoded = ClientAuthenticationCustomCodec.encodeRequest(aString, aByteArray, null, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAuthenticationCustomCodec_decodeResponse() { + int fileClientMessageIndex = 3; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCustomCodec.ResponseParameters parameters = ClientAuthenticationCustomCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(null, parameters.address)); + assertTrue(isEqual(null, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodeRequest() { + int fileClientMessageIndex = 4; + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_decodeResponse() { + int fileClientMessageIndex = 5; + } + + private static class ClientAddClusterViewListenerCodecHandler extends ClientAddClusterViewListenerCodec.AbstractEventHandler { + @Override + public void handleMembersViewEvent(int version, java.util.Collection memberInfos) { + assertTrue(isEqual(anInt, version)); + assertTrue(isEqual(aListOfMemberInfos, memberInfos)); + } + @Override + public void handlePartitionsViewEvent(int version, java.util.Collection>> partitions) { + assertTrue(isEqual(anInt, version)); + assertTrue(isEqual(aListOfUUIDToListOfIntegers, partitions)); + } + } + + @Test + public void test_ClientAddClusterViewListenerCodec_handleMembersViewEvent() { + int fileClientMessageIndex = 6; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddClusterViewListenerCodecHandler handler = new ClientAddClusterViewListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_handlePartitionsViewEvent() { + int fileClientMessageIndex = 7; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddClusterViewListenerCodecHandler handler = new ClientAddClusterViewListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientCreateProxyCodec_encodeRequest() { + int fileClientMessageIndex = 8; + ClientMessage encoded = ClientCreateProxyCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxyCodec_decodeResponse() { + int fileClientMessageIndex = 9; + } + + @Test + public void test_ClientDestroyProxyCodec_encodeRequest() { + int fileClientMessageIndex = 10; + ClientMessage encoded = ClientDestroyProxyCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDestroyProxyCodec_decodeResponse() { + int fileClientMessageIndex = 11; + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 12; + ClientMessage encoded = ClientAddPartitionLostListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 13; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientAddPartitionLostListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientAddPartitionLostListenerCodecHandler extends ClientAddPartitionLostListenerCodec.AbstractEventHandler { + @Override + public void handlePartitionLostEvent(int partitionId, int lostBackupCount, java.util.UUID source) { + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(anInt, lostBackupCount)); + assertTrue(isEqual(null, source)); + } + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_handlePartitionLostEvent() { + int fileClientMessageIndex = 14; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddPartitionLostListenerCodecHandler handler = new ClientAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 15; + ClientMessage encoded = ClientRemovePartitionLostListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 16; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientGetDistributedObjectsCodec_encodeRequest() { + int fileClientMessageIndex = 17; + ClientMessage encoded = ClientGetDistributedObjectsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientGetDistributedObjectsCodec_decodeResponse() { + int fileClientMessageIndex = 18; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDistributedObjectInfo, ClientGetDistributedObjectsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_encodeRequest() { + int fileClientMessageIndex = 19; + ClientMessage encoded = ClientAddDistributedObjectListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_decodeResponse() { + int fileClientMessageIndex = 20; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientAddDistributedObjectListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientAddDistributedObjectListenerCodecHandler extends ClientAddDistributedObjectListenerCodec.AbstractEventHandler { + @Override + public void handleDistributedObjectEvent(java.lang.String name, java.lang.String serviceName, java.lang.String eventType, java.util.UUID source) { + assertTrue(isEqual(aString, name)); + assertTrue(isEqual(aString, serviceName)); + assertTrue(isEqual(aString, eventType)); + assertTrue(isEqual(aUUID, source)); + } + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_handleDistributedObjectEvent() { + int fileClientMessageIndex = 21; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddDistributedObjectListenerCodecHandler handler = new ClientAddDistributedObjectListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_encodeRequest() { + int fileClientMessageIndex = 22; + ClientMessage encoded = ClientRemoveDistributedObjectListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_decodeResponse() { + int fileClientMessageIndex = 23; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientRemoveDistributedObjectListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientPingCodec_encodeRequest() { + int fileClientMessageIndex = 24; + ClientMessage encoded = ClientPingCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientPingCodec_decodeResponse() { + int fileClientMessageIndex = 25; + } + + @Test + public void test_ClientStatisticsCodec_encodeRequest() { + int fileClientMessageIndex = 26; + ClientMessage encoded = ClientStatisticsCodec.encodeRequest(aLong, aString, aByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientStatisticsCodec_decodeResponse() { + int fileClientMessageIndex = 27; + } + + @Test + public void test_ClientDeployClassesCodec_encodeRequest() { + int fileClientMessageIndex = 28; + ClientMessage encoded = ClientDeployClassesCodec.encodeRequest(aListOfStringToByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDeployClassesCodec_decodeResponse() { + int fileClientMessageIndex = 29; + } + + @Test + public void test_ClientCreateProxiesCodec_encodeRequest() { + int fileClientMessageIndex = 30; + ClientMessage encoded = ClientCreateProxiesCodec.encodeRequest(aListOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxiesCodec_decodeResponse() { + int fileClientMessageIndex = 31; + } + + @Test + public void test_ClientLocalBackupListenerCodec_encodeRequest() { + int fileClientMessageIndex = 32; + ClientMessage encoded = ClientLocalBackupListenerCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientLocalBackupListenerCodec_decodeResponse() { + int fileClientMessageIndex = 33; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientLocalBackupListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientLocalBackupListenerCodecHandler extends ClientLocalBackupListenerCodec.AbstractEventHandler { + @Override + public void handleBackupEvent(long sourceInvocationCorrelationId) { + assertTrue(isEqual(aLong, sourceInvocationCorrelationId)); + } + } + + @Test + public void test_ClientLocalBackupListenerCodec_handleBackupEvent() { + int fileClientMessageIndex = 34; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientLocalBackupListenerCodecHandler handler = new ClientLocalBackupListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_encodeRequest() { + int fileClientMessageIndex = 35; + ClientMessage encoded = ClientTriggerPartitionAssignmentCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_decodeResponse() { + int fileClientMessageIndex = 36; + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 37; + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 38; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientAddMigrationListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientAddMigrationListenerCodecHandler extends ClientAddMigrationListenerCodec.AbstractEventHandler { + @Override + public void handleMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int type) { + assertTrue(isEqual(aMigrationState, migrationState)); + assertTrue(isEqual(anInt, type)); + } + @Override + public void handleReplicaMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId, int replicaIndex, java.util.UUID sourceUuid, java.util.UUID destUuid, boolean success, long elapsedTime) { + assertTrue(isEqual(aMigrationState, migrationState)); + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(anInt, replicaIndex)); + assertTrue(isEqual(null, sourceUuid)); + assertTrue(isEqual(null, destUuid)); + assertTrue(isEqual(aBoolean, success)); + assertTrue(isEqual(aLong, elapsedTime)); + } + } + + @Test + public void test_ClientAddMigrationListenerCodec_handleMigrationEvent() { + int fileClientMessageIndex = 39; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddMigrationListenerCodecHandler handler = new ClientAddMigrationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientAddMigrationListenerCodec_handleReplicaMigrationEvent() { + int fileClientMessageIndex = 40; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddMigrationListenerCodecHandler handler = new ClientAddMigrationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 41; + ClientMessage encoded = ClientRemoveMigrationListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 42; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientRemoveMigrationListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientSendSchemaCodec_encodeRequest() { + int fileClientMessageIndex = 43; + ClientMessage encoded = ClientSendSchemaCodec.encodeRequest(aSchema); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendSchemaCodec_decodeResponse() { + int fileClientMessageIndex = 44; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aSetOfUUIDs, ClientSendSchemaCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientFetchSchemaCodec_encodeRequest() { + int fileClientMessageIndex = 45; + ClientMessage encoded = ClientFetchSchemaCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientFetchSchemaCodec_decodeResponse() { + int fileClientMessageIndex = 46; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ClientFetchSchemaCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientSendAllSchemasCodec_encodeRequest() { + int fileClientMessageIndex = 47; + ClientMessage encoded = ClientSendAllSchemasCodec.encodeRequest(aListOfSchemas); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendAllSchemasCodec_decodeResponse() { + int fileClientMessageIndex = 48; + } + + @Test + public void test_MapPutCodec_encodeRequest() { + int fileClientMessageIndex = 49; + ClientMessage encoded = MapPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutCodec_decodeResponse() { + int fileClientMessageIndex = 50; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetCodec_encodeRequest() { + int fileClientMessageIndex = 51; + ClientMessage encoded = MapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeResponse() { + int fileClientMessageIndex = 52; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 53; + ClientMessage encoded = MapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 54; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 55; + ClientMessage encoded = MapReplaceCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 56; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 57; + ClientMessage encoded = MapReplaceIfSameCodec.encodeRequest(aString, aData, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 58; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 59; + ClientMessage encoded = MapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 60; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage encoded = MapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 62; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 63; + ClientMessage encoded = MapRemoveIfSameCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 64; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 65; + ClientMessage encoded = MapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 66; + } + + @Test + public void test_MapFlushCodec_encodeRequest() { + int fileClientMessageIndex = 67; + ClientMessage encoded = MapFlushCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeResponse() { + int fileClientMessageIndex = 68; + } + + @Test + public void test_MapTryRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 69; + ClientMessage encoded = MapTryRemoveCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 70; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapTryPutCodec_encodeRequest() { + int fileClientMessageIndex = 71; + ClientMessage encoded = MapTryPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryPutCodec_decodeResponse() { + int fileClientMessageIndex = 72; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientCodec_encodeRequest() { + int fileClientMessageIndex = 73; + ClientMessage encoded = MapPutTransientCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientCodec_decodeResponse() { + int fileClientMessageIndex = 74; + } + + @Test + public void test_MapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 75; + ClientMessage encoded = MapPutIfAbsentCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentCodec_decodeResponse() { + int fileClientMessageIndex = 76; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetCodec_encodeRequest() { + int fileClientMessageIndex = 77; + ClientMessage encoded = MapSetCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetCodec_decodeResponse() { + int fileClientMessageIndex = 78; + } + + @Test + public void test_MapLockCodec_encodeRequest() { + int fileClientMessageIndex = 79; + ClientMessage encoded = MapLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLockCodec_decodeResponse() { + int fileClientMessageIndex = 80; + } + + @Test + public void test_MapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 81; + ClientMessage encoded = MapTryLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryLockCodec_decodeResponse() { + int fileClientMessageIndex = 82; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 83; + ClientMessage encoded = MapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 84; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 85; + ClientMessage encoded = MapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 86; + } + + @Test + public void test_MapAddInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 87; + ClientMessage encoded = MapAddInterceptorCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 88; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapAddInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 89; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 90; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 91; + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 92; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerToKeyWithPredicateCodecHandler extends MapAddEntryListenerToKeyWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 93; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyWithPredicateCodecHandler handler = new MapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 94; + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 95; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerWithPredicateCodecHandler extends MapAddEntryListenerWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 96; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerWithPredicateCodecHandler handler = new MapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 97; + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 98; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerToKeyCodecHandler extends MapAddEntryListenerToKeyCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { + int fileClientMessageIndex = 99; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyCodecHandler handler = new MapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 100; + ClientMessage encoded = MapAddEntryListenerCodec.encodeRequest(aString, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 101; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerCodecHandler extends MapAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 102; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerCodecHandler handler = new MapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 103; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 104; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 105; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 106; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddPartitionLostListenerCodec.decodeResponse(fromFile))); + } + + private static class MapAddPartitionLostListenerCodecHandler extends MapAddPartitionLostListenerCodec.AbstractEventHandler { + @Override + public void handleMapPartitionLostEvent(int partitionId, java.util.UUID uuid) { + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(aUUID, uuid)); + } + } + + @Test + public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() { + int fileClientMessageIndex = 107; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddPartitionLostListenerCodecHandler handler = new MapAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 109; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetEntryViewCodec_encodeRequest() { + int fileClientMessageIndex = 110; + ClientMessage encoded = MapGetEntryViewCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeResponse() { + int fileClientMessageIndex = 111; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetEntryViewCodec.ResponseParameters parameters = MapGetEntryViewCodec.decodeResponse(fromFile); + assertTrue(isEqual(null, parameters.response)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapEvictCodec_encodeRequest() { + int fileClientMessageIndex = 112; + ClientMessage encoded = MapEvictCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeResponse() { + int fileClientMessageIndex = 113; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapEvictCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage encoded = MapEvictAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeResponse() { + int fileClientMessageIndex = 115; + } + + @Test + public void test_MapLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 116; + ClientMessage encoded = MapLoadAllCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 117; + } + + @Test + public void test_MapLoadGivenKeysCodec_encodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeResponse() { + int fileClientMessageIndex = 119; + } + + @Test + public void test_MapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage encoded = MapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 122; + ClientMessage encoded = MapGetAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 123; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 124; + ClientMessage encoded = MapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 125; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 126; + ClientMessage encoded = MapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 127; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 128; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 129; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntriesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntriesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddIndexCodec_encodeRequest() { + int fileClientMessageIndex = 134; + ClientMessage encoded = MapAddIndexCodec.encodeRequest(aString, anIndexConfig); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeResponse() { + int fileClientMessageIndex = 135; + } + + @Test + public void test_MapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage encoded = MapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 137; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 138; + ClientMessage encoded = MapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 139; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 140; + ClientMessage encoded = MapPutAllCodec.encodeRequest(aString, aListOfDataToData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 141; + } + + @Test + public void test_MapClearCodec_encodeRequest() { + int fileClientMessageIndex = 142; + ClientMessage encoded = MapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeResponse() { + int fileClientMessageIndex = 143; + } + + @Test + public void test_MapExecuteOnKeyCodec_encodeRequest() { + int fileClientMessageIndex = 144; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeResponse() { + int fileClientMessageIndex = 145; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapExecuteOnKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSubmitToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 146; + ClientMessage encoded = MapSubmitToKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 147; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapSubmitToKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 148; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 149; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnAllKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 150; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 151; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnKeysCodec_encodeRequest() { + int fileClientMessageIndex = 152; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeRequest(aString, aData, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeResponse() { + int fileClientMessageIndex = 153; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 154; + ClientMessage encoded = MapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 155; + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 156; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 157; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapKeySetWithPagingPredicateCodec.ResponseParameters parameters = MapKeySetWithPagingPredicateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfData, parameters.response)); + assertTrue(isEqual(anAnchorDataListHolder, parameters.anchorDataList)); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 158; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 159; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapValuesWithPagingPredicateCodec.ResponseParameters parameters = MapValuesWithPagingPredicateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfData, parameters.response)); + assertTrue(isEqual(anAnchorDataListHolder, parameters.anchorDataList)); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 160; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 161; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEntriesWithPagingPredicateCodec.ResponseParameters parameters = MapEntriesWithPagingPredicateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfDataToData, parameters.response)); + assertTrue(isEqual(anAnchorDataListHolder, parameters.anchorDataList)); + } + + @Test + public void test_MapFetchKeysCodec_encodeRequest() { + int fileClientMessageIndex = 162; + ClientMessage encoded = MapFetchKeysCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeResponse() { + int fileClientMessageIndex = 163; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchKeysCodec.ResponseParameters parameters = MapFetchKeysCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_MapFetchEntriesCodec_encodeRequest() { + int fileClientMessageIndex = 164; + ClientMessage encoded = MapFetchEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 165; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchEntriesCodec.ResponseParameters parameters = MapFetchEntriesCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + } + + @Test + public void test_MapAggregateCodec_encodeRequest() { + int fileClientMessageIndex = 166; + ClientMessage encoded = MapAggregateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeResponse() { + int fileClientMessageIndex = 167; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapAggregateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAggregateWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 168; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 169; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapAggregateWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectCodec_encodeRequest() { + int fileClientMessageIndex = 170; + ClientMessage encoded = MapProjectCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeResponse() { + int fileClientMessageIndex = 171; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 172; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 173; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 174; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 175; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchNearCacheInvalidationMetadataCodec.ResponseParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfStringToListOfIntegerToLong, parameters.namePartitionSequenceList)); + assertTrue(isEqual(aListOfIntegerToUUID, parameters.partitionUuidList)); + } + + @Test + public void test_MapRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 176; + ClientMessage encoded = MapRemoveAllCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 177; + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 178; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeRequest(aString, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 179; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddNearCacheInvalidationListenerCodec.decodeResponse(fromFile))); + } + + private static class MapAddNearCacheInvalidationListenerCodecHandler extends MapAddNearCacheInvalidationListenerCodec.AbstractEventHandler { + @Override + public void handleIMapInvalidationEvent(com.hazelcast.internal.serialization.Data key, java.util.UUID sourceUuid, java.util.UUID partitionUuid, long sequence) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(aUUID, sourceUuid)); + assertTrue(isEqual(aUUID, partitionUuid)); + assertTrue(isEqual(aLong, sequence)); + } + @Override + public void handleIMapBatchInvalidationEvent(java.util.Collection keys, java.util.Collection sourceUuids, java.util.Collection partitionUuids, java.util.Collection sequences) { + assertTrue(isEqual(aListOfData, keys)); + assertTrue(isEqual(aListOfUUIDs, sourceUuids)); + assertTrue(isEqual(aListOfUUIDs, partitionUuids)); + assertTrue(isEqual(aListOfLongs, sequences)); + } + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_handleIMapInvalidationEvent() { + int fileClientMessageIndex = 180; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_handleIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 181; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapFetchWithQueryCodec_encodeRequest() { + int fileClientMessageIndex = 182; + ClientMessage encoded = MapFetchWithQueryCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchWithQueryCodec_decodeResponse() { + int fileClientMessageIndex = 183; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchWithQueryCodec.ResponseParameters parameters = MapFetchWithQueryCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfData, parameters.results)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + } + + @Test + public void test_MapEventJournalSubscribeCodec_encodeRequest() { + int fileClientMessageIndex = 184; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 185; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEventJournalSubscribeCodec.ResponseParameters parameters = MapEventJournalSubscribeCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.oldestSequence)); + assertTrue(isEqual(aLong, parameters.newestSequence)); + } + + @Test + public void test_MapEventJournalReadCodec_encodeRequest() { + int fileClientMessageIndex = 186; + ClientMessage encoded = MapEventJournalReadCodec.encodeRequest(aString, aLong, anInt, anInt, null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalReadCodec_decodeResponse() { + int fileClientMessageIndex = 187; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEventJournalReadCodec.ResponseParameters parameters = MapEventJournalReadCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.readCount)); + assertTrue(isEqual(aListOfData, parameters.items)); + assertTrue(isEqual(null, parameters.itemSeqs)); + assertTrue(isEqual(aLong, parameters.nextSeq)); + } + + @Test + public void test_MapSetTtlCodec_encodeRequest() { + int fileClientMessageIndex = 188; + ClientMessage encoded = MapSetTtlCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeResponse() { + int fileClientMessageIndex = 189; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapSetTtlCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 190; + ClientMessage encoded = MapPutWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 191; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 192; + ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 193; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutTransientWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 194; + ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 195; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutIfAbsentWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 196; + ClientMessage encoded = MapSetWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 197; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapSetWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceAllCodec_encodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage encoded = MapReplaceAllCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceAllCodec_decodeResponse() { + int fileClientMessageIndex = 199; + } + + @Test + public void test_MapPutAllWithMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage encoded = MapPutAllWithMetadataCodec.encodeRequest(aString, aListOfSimpleEntryViews); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllWithMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 201; + } + + @Test + public void test_MultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage encoded = MultiMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 204; + ClientMessage encoded = MultiMapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 205; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 206; + ClientMessage encoded = MultiMapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 207; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 208; + ClientMessage encoded = MultiMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 209; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage encoded = MultiMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage encoded = MultiMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 213; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MultiMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 214; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 215; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 216; + ClientMessage encoded = MultiMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 217; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsEntryCodec_encodeRequest() { + int fileClientMessageIndex = 218; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeResponse() { + int fileClientMessageIndex = 219; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 220; + ClientMessage encoded = MultiMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 221; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 222; + ClientMessage encoded = MultiMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 223; + } + + @Test + public void test_MultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 224; + ClientMessage encoded = MultiMapValueCountCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 225; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 226; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 227; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MultiMapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); + } + + private static class MultiMapAddEntryListenerToKeyCodecHandler extends MultiMapAddEntryListenerToKeyCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_handleEntryEvent() { + int fileClientMessageIndex = 228; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerToKeyCodecHandler handler = new MultiMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 229; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 230; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MultiMapAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class MultiMapAddEntryListenerCodecHandler extends MultiMapAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MultiMapAddEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 231; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerCodecHandler handler = new MultiMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 232; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 233; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapLockCodec_encodeRequest() { + int fileClientMessageIndex = 234; + ClientMessage encoded = MultiMapLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapLockCodec_decodeResponse() { + int fileClientMessageIndex = 235; + } + + @Test + public void test_MultiMapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 236; + ClientMessage encoded = MultiMapTryLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapTryLockCodec_decodeResponse() { + int fileClientMessageIndex = 237; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 238; + ClientMessage encoded = MultiMapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 239; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 240; + ClientMessage encoded = MultiMapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 241; + } + + @Test + public void test_MultiMapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 242; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 243; + } + + @Test + public void test_MultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 246; + ClientMessage encoded = MultiMapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 247; + } + + @Test + public void test_MultiMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 248; + ClientMessage encoded = MultiMapPutAllCodec.encodeRequest(aString, aListOfDataToListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 249; + } + + @Test + public void test_QueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage encoded = QueueOfferCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePutCodec_encodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage encoded = QueuePutCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeResponse() { + int fileClientMessageIndex = 253; + } + + @Test + public void test_QueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage encoded = QueueSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage encoded = QueueRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 258; + ClientMessage encoded = QueuePollCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 259; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, QueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 260; + ClientMessage encoded = QueueTakeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 261; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, QueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 262; + ClientMessage encoded = QueuePeekCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 263; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, QueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 264; + ClientMessage encoded = QueueIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 265; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeRequest() { + int fileClientMessageIndex = 266; + ClientMessage encoded = QueueDrainToCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeResponse() { + int fileClientMessageIndex = 267; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_encodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeResponse() { + int fileClientMessageIndex = 269; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToMaxSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsCodec_encodeRequest() { + int fileClientMessageIndex = 270; + ClientMessage encoded = QueueContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeResponse() { + int fileClientMessageIndex = 271; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 272; + ClientMessage encoded = QueueContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 273; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 274; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 275; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 276; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 277; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeRequest() { + int fileClientMessageIndex = 278; + ClientMessage encoded = QueueClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeResponse() { + int fileClientMessageIndex = 279; + } + + @Test + public void test_QueueAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 280; + ClientMessage encoded = QueueAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 281; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 282; + ClientMessage encoded = QueueAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 283; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, QueueAddListenerCodec.decodeResponse(fromFile))); + } + + private static class QueueAddListenerCodecHandler extends QueueAddListenerCodec.AbstractEventHandler { + @Override + public void handleItemEvent(com.hazelcast.internal.serialization.Data item, java.util.UUID uuid, int eventType) { + assertTrue(isEqual(null, item)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, eventType)); + } + } + + @Test + public void test_QueueAddListenerCodec_handleItemEvent() { + int fileClientMessageIndex = 284; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddListenerCodecHandler handler = new QueueAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_QueueRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 285; + ClientMessage encoded = QueueRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 286; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 287; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 288; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 289; + ClientMessage encoded = QueueIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 290; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishCodec_encodeRequest() { + int fileClientMessageIndex = 291; + ClientMessage encoded = TopicPublishCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeResponse() { + int fileClientMessageIndex = 292; + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 293; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 294; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, TopicAddMessageListenerCodec.decodeResponse(fromFile))); + } + + private static class TopicAddMessageListenerCodecHandler extends TopicAddMessageListenerCodec.AbstractEventHandler { + @Override + public void handleTopicEvent(com.hazelcast.internal.serialization.Data item, long publishTime, java.util.UUID uuid) { + assertTrue(isEqual(aData, item)); + assertTrue(isEqual(aLong, publishTime)); + assertTrue(isEqual(aUUID, uuid)); + } + } + + @Test + public void test_TopicAddMessageListenerCodec_handleTopicEvent() { + int fileClientMessageIndex = 295; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicAddMessageListenerCodecHandler handler = new TopicAddMessageListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 296; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 297; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TopicRemoveMessageListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishAllCodec_encodeRequest() { + int fileClientMessageIndex = 298; + ClientMessage encoded = TopicPublishAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeResponse() { + int fileClientMessageIndex = 299; + } + + @Test + public void test_ListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 300; + ClientMessage encoded = ListSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 301; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsCodec_encodeRequest() { + int fileClientMessageIndex = 302; + ClientMessage encoded = ListContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeResponse() { + int fileClientMessageIndex = 303; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 304; + ClientMessage encoded = ListContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 305; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddCodec_encodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage encoded = ListAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeResponse() { + int fileClientMessageIndex = 307; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage encoded = ListRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 310; + ClientMessage encoded = ListAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 311; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 312; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 313; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 314; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 315; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeRequest() { + int fileClientMessageIndex = 316; + ClientMessage encoded = ListClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeResponse() { + int fileClientMessageIndex = 317; + } + + @Test + public void test_ListGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 318; + ClientMessage encoded = ListGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 319; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 320; + ClientMessage encoded = ListAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 321; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ListAddListenerCodec.decodeResponse(fromFile))); + } + + private static class ListAddListenerCodecHandler extends ListAddListenerCodec.AbstractEventHandler { + @Override + public void handleItemEvent(com.hazelcast.internal.serialization.Data item, java.util.UUID uuid, int eventType) { + assertTrue(isEqual(null, item)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, eventType)); + } + } + + @Test + public void test_ListAddListenerCodec_handleItemEvent() { + int fileClientMessageIndex = 322; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddListenerCodecHandler handler = new ListAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ListRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 323; + ClientMessage encoded = ListRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 324; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 325; + ClientMessage encoded = ListIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 326; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 327; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeRequest(aString, anInt, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 328; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListGetCodec_encodeRequest() { + int fileClientMessageIndex = 329; + ClientMessage encoded = ListGetCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeResponse() { + int fileClientMessageIndex = 330; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ListGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSetCodec_encodeRequest() { + int fileClientMessageIndex = 331; + ClientMessage encoded = ListSetCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeResponse() { + int fileClientMessageIndex = 332; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ListSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage encoded = ListAddWithIndexCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 334; + } + + @Test + public void test_ListRemoveWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 335; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 336; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ListRemoveWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListLastIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage encoded = ListLastIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListLastIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 339; + ClientMessage encoded = ListIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 340; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSubCodec_encodeRequest() { + int fileClientMessageIndex = 341; + ClientMessage encoded = ListSubCodec.encodeRequest(aString, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeResponse() { + int fileClientMessageIndex = 342; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListSubCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 343; + ClientMessage encoded = ListIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 344; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 345; + ClientMessage encoded = ListListIteratorCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 346; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 347; + ClientMessage encoded = SetSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 348; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsCodec_encodeRequest() { + int fileClientMessageIndex = 349; + ClientMessage encoded = SetContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeResponse() { + int fileClientMessageIndex = 350; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 351; + ClientMessage encoded = SetContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 352; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddCodec_encodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage encoded = SetAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeResponse() { + int fileClientMessageIndex = 354; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage encoded = SetRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 357; + ClientMessage encoded = SetAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 358; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 359; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 360; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 361; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 362; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeRequest() { + int fileClientMessageIndex = 363; + ClientMessage encoded = SetClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeResponse() { + int fileClientMessageIndex = 364; + } + + @Test + public void test_SetGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 365; + ClientMessage encoded = SetGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 366; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, SetGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 367; + ClientMessage encoded = SetAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 368; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, SetAddListenerCodec.decodeResponse(fromFile))); + } + + private static class SetAddListenerCodecHandler extends SetAddListenerCodec.AbstractEventHandler { + @Override + public void handleItemEvent(com.hazelcast.internal.serialization.Data item, java.util.UUID uuid, int eventType) { + assertTrue(isEqual(null, item)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, eventType)); + } + } + + @Test + public void test_SetAddListenerCodec_handleItemEvent() { + int fileClientMessageIndex = 369; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddListenerCodecHandler handler = new SetAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_SetRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 370; + ClientMessage encoded = SetRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 371; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 372; + ClientMessage encoded = SetIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 373; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockLockCodec_encodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage encoded = FencedLockLockCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockLockCodec_decodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 376; + ClientMessage encoded = FencedLockTryLockCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockTryLockCodec_decodeResponse() { + int fileClientMessageIndex = 377; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 378; + ClientMessage encoded = FencedLockUnlockCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 379; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, FencedLockUnlockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_encodeRequest() { + int fileClientMessageIndex = 380; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeResponse() { + int fileClientMessageIndex = 381; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockGetLockOwnershipCodec.ResponseParameters parameters = FencedLockGetLockOwnershipCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.fence)); + assertTrue(isEqual(anInt, parameters.lockCount)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_ExecutorServiceShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 382; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 383; + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 384; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 385; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 386; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 387; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_encodeRequest() { + int fileClientMessageIndex = 388; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeRequest(aUUID, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeResponse() { + int fileClientMessageIndex = 389; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 390; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeRequest(aString, aUUID, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 391; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ExecutorServiceSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 392; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeRequest(aString, aUUID, aData, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeResponse() { + int fileClientMessageIndex = 393; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ExecutorServiceSubmitToMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongApplyCodec_encodeRequest() { + int fileClientMessageIndex = 394; + ClientMessage encoded = AtomicLongApplyCodec.encodeRequest(aRaftGroupId, aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeResponse() { + int fileClientMessageIndex = 395; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicLongApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAlterCodec_encodeRequest() { + int fileClientMessageIndex = 396; + ClientMessage encoded = AtomicLongAlterCodec.encodeRequest(aRaftGroupId, aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeResponse() { + int fileClientMessageIndex = 397; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAlterCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAddAndGetCodec_encodeRequest() { + int fileClientMessageIndex = 398; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeResponse() { + int fileClientMessageIndex = 399; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAddAndGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 400; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 401; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicLongCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetCodec_encodeRequest() { + int fileClientMessageIndex = 402; + ClientMessage encoded = AtomicLongGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeResponse() { + int fileClientMessageIndex = 403; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndAddCodec_encodeRequest() { + int fileClientMessageIndex = 404; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeResponse() { + int fileClientMessageIndex = 405; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 406; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 407; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefApplyCodec_encodeRequest() { + int fileClientMessageIndex = 408; + ClientMessage encoded = AtomicRefApplyCodec.encodeRequest(aRaftGroupId, aString, aData, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefApplyCodec_decodeResponse() { + int fileClientMessageIndex = 409; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicRefApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 410; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 411; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefContainsCodec_encodeRequest() { + int fileClientMessageIndex = 412; + ClientMessage encoded = AtomicRefContainsCodec.encodeRequest(aRaftGroupId, aString, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeResponse() { + int fileClientMessageIndex = 413; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefGetCodec_encodeRequest() { + int fileClientMessageIndex = 414; + ClientMessage encoded = AtomicRefGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeResponse() { + int fileClientMessageIndex = 415; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicRefGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefSetCodec_encodeRequest() { + int fileClientMessageIndex = 416; + ClientMessage encoded = AtomicRefSetCodec.encodeRequest(aRaftGroupId, aString, null, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeResponse() { + int fileClientMessageIndex = 417; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicRefSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_encodeRequest() { + int fileClientMessageIndex = 418; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeResponse() { + int fileClientMessageIndex = 419; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchTrySetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchAwaitCodec_encodeRequest() { + int fileClientMessageIndex = 420; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeRequest(aRaftGroupId, aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeResponse() { + int fileClientMessageIndex = 421; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchAwaitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchCountDownCodec_encodeRequest() { + int fileClientMessageIndex = 422; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeRequest(aRaftGroupId, aString, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeResponse() { + int fileClientMessageIndex = 423; + } + + @Test + public void test_CountDownLatchGetCountCodec_encodeRequest() { + int fileClientMessageIndex = 424; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeResponse() { + int fileClientMessageIndex = 425; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchGetRoundCodec_encodeRequest() { + int fileClientMessageIndex = 426; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeResponse() { + int fileClientMessageIndex = 427; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetRoundCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreInitCodec_encodeRequest() { + int fileClientMessageIndex = 428; + ClientMessage encoded = SemaphoreInitCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeResponse() { + int fileClientMessageIndex = 429; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreInitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAcquireCodec_encodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage encoded = SemaphoreAcquireCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAcquireCodec_decodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreAcquireCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreReleaseCodec_encodeRequest() { + int fileClientMessageIndex = 432; + ClientMessage encoded = SemaphoreReleaseCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreReleaseCodec_decodeResponse() { + int fileClientMessageIndex = 433; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreReleaseCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreDrainCodec_encodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage encoded = SemaphoreDrainCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreDrainCodec_decodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreDrainCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreChangeCodec_encodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage encoded = SemaphoreChangeCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreChangeCodec_decodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreChangeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_encodeRequest() { + int fileClientMessageIndex = 438; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeResponse() { + int fileClientMessageIndex = 439; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreAvailablePermitsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeRequest() { + int fileClientMessageIndex = 440; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeResponse() { + int fileClientMessageIndex = 441; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreGetSemaphoreTypeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 442; + ClientMessage encoded = ReplicatedMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 443; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ReplicatedMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 444; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 445; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ReplicatedMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 446; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 447; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 449; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 450; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 451; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 452; + ClientMessage encoded = ReplicatedMapGetCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 453; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ReplicatedMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 454; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 455; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ReplicatedMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 456; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeRequest(aString, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 457; + } + + @Test + public void test_ReplicatedMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 458; + ClientMessage encoded = ReplicatedMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 459; + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 460; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 461; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler extends ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 462; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 463; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 464; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerWithPredicateCodecHandler extends ReplicatedMapAddEntryListenerWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 465; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerToKeyCodecHandler extends ReplicatedMapAddEntryListenerToKeyCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_handleEntryEvent() { + int fileClientMessageIndex = 468; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 469; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 470; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerCodecHandler extends ReplicatedMapAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 471; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerCodecHandler handler = new ReplicatedMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 472; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 473; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 474; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 475; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 476; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 477; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 478; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 479; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ReplicatedMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 480; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 481; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddNearCacheEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddNearCacheEntryListenerCodecHandler extends ReplicatedMapAddNearCacheEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, value)); + assertTrue(isEqual(null, oldValue)); + assertTrue(isEqual(null, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 482; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddNearCacheEntryListenerCodecHandler handler = new ReplicatedMapAddNearCacheEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 483; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 484; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 485; + ClientMessage encoded = TransactionalMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 486; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_encodeRequest() { + int fileClientMessageIndex = 487; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeResponse() { + int fileClientMessageIndex = 488; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapGetForUpdateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 489; + ClientMessage encoded = TransactionalMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 490; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 491; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 492; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 493; + ClientMessage encoded = TransactionalMapPutCodec.encodeRequest(aString, aUUID, aLong, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 494; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSetCodec_encodeRequest() { + int fileClientMessageIndex = 495; + ClientMessage encoded = TransactionalMapSetCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSetCodec_decodeResponse() { + int fileClientMessageIndex = 496; + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 497; + ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_decodeResponse() { + int fileClientMessageIndex = 498; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 499; + ClientMessage encoded = TransactionalMapReplaceCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 500; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 501; + ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeRequest(aString, aUUID, aLong, aData, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 502; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 503; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 504; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 505; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 506; + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 507; + ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 508; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 509; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 510; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 511; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 512; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 513; + ClientMessage encoded = TransactionalMapValuesCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 514; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 515; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 516; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 517; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 518; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 519; + ClientMessage encoded = TransactionalMultiMapPutCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 520; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 521; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 522; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 523; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 524; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 525; + ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_decodeResponse() { + int fileClientMessageIndex = 526; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 527; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 528; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 529; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 530; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetAddCodec_encodeRequest() { + int fileClientMessageIndex = 531; + ClientMessage encoded = TransactionalSetAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeResponse() { + int fileClientMessageIndex = 532; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 533; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 534; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 535; + ClientMessage encoded = TransactionalSetSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 536; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalSetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListAddCodec_encodeRequest() { + int fileClientMessageIndex = 537; + ClientMessage encoded = TransactionalListAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeResponse() { + int fileClientMessageIndex = 538; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 539; + ClientMessage encoded = TransactionalListRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 540; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 541; + ClientMessage encoded = TransactionalListSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 542; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 543; + ClientMessage encoded = TransactionalQueueOfferCodec.encodeRequest(aString, aUUID, aLong, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueOfferCodec_decodeResponse() { + int fileClientMessageIndex = 544; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalQueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 545; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 546; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalQueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 547; + ClientMessage encoded = TransactionalQueuePollCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 548; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalQueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 549; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 550; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalQueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 551; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 552; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalQueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 553; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 554; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CacheAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class CacheAddEntryListenerCodecHandler extends CacheAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleCacheEvent(int type, java.util.Collection keys, int completionId) { + assertTrue(isEqual(anInt, type)); + assertTrue(isEqual(aListOfCacheEventData, keys)); + assertTrue(isEqual(anInt, completionId)); + } + } + + @Test + public void test_CacheAddEntryListenerCodec_handleCacheEvent() { + int fileClientMessageIndex = 555; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddEntryListenerCodecHandler handler = new CacheAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheClearCodec_encodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage encoded = CacheClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeResponse() { + int fileClientMessageIndex = 557; + } + + @Test + public void test_CacheRemoveAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 558; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 559; + } + + @Test + public void test_CacheRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 560; + ClientMessage encoded = CacheRemoveAllCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 561; + } + + @Test + public void test_CacheContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 562; + ClientMessage encoded = CacheContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 563; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheCreateConfigCodec_encodeRequest() { + int fileClientMessageIndex = 564; + ClientMessage encoded = CacheCreateConfigCodec.encodeRequest(aCacheConfigHolder, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeResponse() { + int fileClientMessageIndex = 565; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheCreateConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeRequest() { + int fileClientMessageIndex = 566; + ClientMessage encoded = CacheDestroyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeResponse() { + int fileClientMessageIndex = 567; + } + + @Test + public void test_CacheEntryProcessorCodec_encodeRequest() { + int fileClientMessageIndex = 568; + ClientMessage encoded = CacheEntryProcessorCodec.encodeRequest(aString, aData, aData, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEntryProcessorCodec_decodeResponse() { + int fileClientMessageIndex = 569; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheEntryProcessorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 570; + ClientMessage encoded = CacheGetAllCodec.encodeRequest(aString, aListOfData, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 571; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, CacheGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 572; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeRequest(aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 573; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetAndRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 574; + ClientMessage encoded = CacheGetAndReplaceCodec.encodeRequest(aString, aData, aData, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 575; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetAndReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 576; + ClientMessage encoded = CacheGetConfigCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeResponse() { + int fileClientMessageIndex = 577; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetCodec_encodeRequest() { + int fileClientMessageIndex = 578; + ClientMessage encoded = CacheGetCodec.encodeRequest(aString, aData, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeResponse() { + int fileClientMessageIndex = 579; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheIterateCodec_encodeRequest() { + int fileClientMessageIndex = 580; + ClientMessage encoded = CacheIterateCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeResponse() { + int fileClientMessageIndex = 581; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateCodec.ResponseParameters parameters = CacheIterateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_CacheListenerRegistrationCodec_encodeRequest() { + int fileClientMessageIndex = 582; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeRequest(aString, aData, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeResponse() { + int fileClientMessageIndex = 583; + } + + @Test + public void test_CacheLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 584; + ClientMessage encoded = CacheLoadAllCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 585; + } + + @Test + public void test_CacheManagementConfigCodec_encodeRequest() { + int fileClientMessageIndex = 586; + ClientMessage encoded = CacheManagementConfigCodec.encodeRequest(aString, aBoolean, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeResponse() { + int fileClientMessageIndex = 587; + } + + @Test + public void test_CachePutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 588; + ClientMessage encoded = CachePutIfAbsentCodec.encodeRequest(aString, aData, aData, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutIfAbsentCodec_decodeResponse() { + int fileClientMessageIndex = 589; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CachePutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutCodec_encodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage encoded = CachePutCodec.encodeRequest(aString, aData, aData, null, aBoolean, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutCodec_decodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CachePutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 592; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 593; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 594; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 595; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveInvalidationListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 596; + ClientMessage encoded = CacheRemoveCodec.encodeRequest(aString, aData, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 597; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 598; + ClientMessage encoded = CacheReplaceCodec.encodeRequest(aString, aData, null, aData, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 599; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeRequest() { + int fileClientMessageIndex = 600; + ClientMessage encoded = CacheSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeResponse() { + int fileClientMessageIndex = 601; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CacheSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 602; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 603; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CacheAddPartitionLostListenerCodec.decodeResponse(fromFile))); + } + + private static class CacheAddPartitionLostListenerCodecHandler extends CacheAddPartitionLostListenerCodec.AbstractEventHandler { + @Override + public void handleCachePartitionLostEvent(int partitionId, java.util.UUID uuid) { + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(aUUID, uuid)); + } + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_handleCachePartitionLostEvent() { + int fileClientMessageIndex = 604; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddPartitionLostListenerCodecHandler handler = new CacheAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 605; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 606; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutAllCodec_encodeRequest() { + int fileClientMessageIndex = 607; + ClientMessage encoded = CachePutAllCodec.encodeRequest(aString, aListOfDataToData, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeResponse() { + int fileClientMessageIndex = 608; + } + + @Test + public void test_CacheIterateEntriesCodec_encodeRequest() { + int fileClientMessageIndex = 609; + ClientMessage encoded = CacheIterateEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 610; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateEntriesCodec.ResponseParameters parameters = CacheIterateEntriesCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 611; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 612; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CacheAddNearCacheInvalidationListenerCodec.decodeResponse(fromFile))); + } + + private static class CacheAddNearCacheInvalidationListenerCodecHandler extends CacheAddNearCacheInvalidationListenerCodec.AbstractEventHandler { + @Override + public void handleCacheInvalidationEvent(java.lang.String name, com.hazelcast.internal.serialization.Data key, java.util.UUID sourceUuid, java.util.UUID partitionUuid, long sequence) { + assertTrue(isEqual(aString, name)); + assertTrue(isEqual(null, key)); + assertTrue(isEqual(null, sourceUuid)); + assertTrue(isEqual(aUUID, partitionUuid)); + assertTrue(isEqual(aLong, sequence)); + } + @Override + public void handleCacheBatchInvalidationEvent(java.lang.String name, java.util.Collection keys, java.util.Collection sourceUuids, java.util.Collection partitionUuids, java.util.Collection sequences) { + assertTrue(isEqual(aString, name)); + assertTrue(isEqual(aListOfData, keys)); + assertTrue(isEqual(aListOfUUIDs, sourceUuids)); + assertTrue(isEqual(aListOfUUIDs, partitionUuids)); + assertTrue(isEqual(aListOfLongs, sequences)); + } + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_handleCacheInvalidationEvent() { + int fileClientMessageIndex = 613; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_handleCacheBatchInvalidationEvent() { + int fileClientMessageIndex = 614; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 615; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheFetchNearCacheInvalidationMetadataCodec.ResponseParameters parameters = CacheFetchNearCacheInvalidationMetadataCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfStringToListOfIntegerToLong, parameters.namePartitionSequenceList)); + assertTrue(isEqual(aListOfIntegerToUUID, parameters.partitionUuidList)); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_encodeRequest() { + int fileClientMessageIndex = 617; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 618; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEventJournalSubscribeCodec.ResponseParameters parameters = CacheEventJournalSubscribeCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.oldestSequence)); + assertTrue(isEqual(aLong, parameters.newestSequence)); + } + + @Test + public void test_CacheEventJournalReadCodec_encodeRequest() { + int fileClientMessageIndex = 619; + ClientMessage encoded = CacheEventJournalReadCodec.encodeRequest(aString, aLong, anInt, anInt, null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalReadCodec_decodeResponse() { + int fileClientMessageIndex = 620; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEventJournalReadCodec.ResponseParameters parameters = CacheEventJournalReadCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.readCount)); + assertTrue(isEqual(aListOfData, parameters.items)); + assertTrue(isEqual(null, parameters.itemSeqs)); + assertTrue(isEqual(aLong, parameters.nextSeq)); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_encodeRequest() { + int fileClientMessageIndex = 621; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeRequest(aString, aListOfData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeResponse() { + int fileClientMessageIndex = 622; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheSetExpiryPolicyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeRequest(anXid); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeResponse() { + int fileClientMessageIndex = 624; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeRequest() { + int fileClientMessageIndex = 625; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeResponse() { + int fileClientMessageIndex = 626; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfXids, XATransactionCollectTransactionsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionFinalizeCodec_encodeRequest() { + int fileClientMessageIndex = 627; + ClientMessage encoded = XATransactionFinalizeCodec.encodeRequest(anXid, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeResponse() { + int fileClientMessageIndex = 628; + } + + @Test + public void test_XATransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 629; + ClientMessage encoded = XATransactionCommitCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 630; + } + + @Test + public void test_XATransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 631; + ClientMessage encoded = XATransactionCreateCodec.encodeRequest(anXid, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 632; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeRequest() { + int fileClientMessageIndex = 633; + ClientMessage encoded = XATransactionPrepareCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeResponse() { + int fileClientMessageIndex = 634; + } + + @Test + public void test_XATransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 635; + ClientMessage encoded = XATransactionRollbackCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 636; + } + + @Test + public void test_TransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 637; + ClientMessage encoded = TransactionCommitCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 638; + } + + @Test + public void test_TransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 639; + ClientMessage encoded = TransactionCreateCodec.encodeRequest(aLong, anInt, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 640; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, TransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 641; + ClientMessage encoded = TransactionRollbackCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 642; + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeRequest() { + int fileClientMessageIndex = 643; + ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeRequest(aString, aString, aData, anInt, anInt, aLong, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeResponse() { + int fileClientMessageIndex = 644; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ContinuousQueryPublisherCreateWithValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_encodeRequest() { + int fileClientMessageIndex = 645; + ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeRequest(aString, aString, aData, anInt, anInt, aLong, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_decodeResponse() { + int fileClientMessageIndex = 646; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ContinuousQueryPublisherCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_encodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryMadePublishableCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ContinuousQueryAddListenerCodec.decodeResponse(fromFile))); + } + + private static class ContinuousQueryAddListenerCodecHandler extends ContinuousQueryAddListenerCodec.AbstractEventHandler { + @Override + public void handleQueryCacheSingleEvent(com.hazelcast.map.impl.querycache.event.QueryCacheEventData data) { + assertTrue(isEqual(aQueryCacheEventData, data)); + } + @Override + public void handleQueryCacheBatchEvent(java.util.Collection events, java.lang.String source, int partitionId) { + assertTrue(isEqual(aListOfQueryCacheEventData, events)); + assertTrue(isEqual(aString, source)); + assertTrue(isEqual(anInt, partitionId)); + } + } + + @Test + public void test_ContinuousQueryAddListenerCodec_handleQueryCacheSingleEvent() { + int fileClientMessageIndex = 651; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_handleQueryCacheBatchEvent() { + int fileClientMessageIndex = 652; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_encodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeRequest(aString, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQuerySetReadCursorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_encodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryDestroyCacheCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeRequest() { + int fileClientMessageIndex = 657; + ClientMessage encoded = RingbufferSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeResponse() { + int fileClientMessageIndex = 658; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 659; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 660; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferTailSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 661; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 662; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferHeadSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 663; + ClientMessage encoded = RingbufferCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 664; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 665; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 666; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddCodec_encodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage encoded = RingbufferAddCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadOneCodec_encodeRequest() { + int fileClientMessageIndex = 669; + ClientMessage encoded = RingbufferReadOneCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeResponse() { + int fileClientMessageIndex = 670; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, RingbufferReadOneCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 671; + ClientMessage encoded = RingbufferAddAllCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 672; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadManyCodec_encodeRequest() { + int fileClientMessageIndex = 673; + ClientMessage encoded = RingbufferReadManyCodec.encodeRequest(aString, aLong, anInt, anInt, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadManyCodec_decodeResponse() { + int fileClientMessageIndex = 674; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferReadManyCodec.ResponseParameters parameters = RingbufferReadManyCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.readCount)); + assertTrue(isEqual(aListOfData, parameters.items)); + assertTrue(isEqual(null, parameters.itemSeqs)); + assertTrue(isEqual(aLong, parameters.nextSeq)); + } + + @Test + public void test_DurableExecutorShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 675; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 676; + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 677; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 678; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, DurableExecutorIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, DurableExecutorSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_encodeRequest() { + int fileClientMessageIndex = 681; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeResponse() { + int fileClientMessageIndex = 682; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, DurableExecutorRetrieveResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 683; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 684; + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 685; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 686; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, DurableExecutorRetrieveAndDisposeResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CardinalityEstimatorAddCodec_encodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeResponse() { + int fileClientMessageIndex = 688; + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeRequest() { + int fileClientMessageIndex = 689; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeResponse() { + int fileClientMessageIndex = 690; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CardinalityEstimatorEstimateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 691; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 692; + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 693; + ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeRequest(aString, aByte, aString, aData, aLong, aLong, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 694; + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 695; + ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeRequest(aString, aUUID, aByte, aString, aData, aLong, aLong, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_decodeResponse() { + int fileClientMessageIndex = 696; + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeRequest() { + int fileClientMessageIndex = 697; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeResponse() { + int fileClientMessageIndex = 698; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfScheduledTaskHandler, ScheduledExecutorGetAllScheduledFuturesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 699; + ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 700; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromPartitionCodec.ResponseParameters parameters = ScheduledExecutorGetStatsFromPartitionCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.lastIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalRuns)); + assertTrue(isEqual(aLong, parameters.totalRunTimeNanos)); + assertTrue(isEqual(aLong, parameters.lastRunDurationNanos)); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 701; + ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 702; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromMemberCodec.ResponseParameters parameters = ScheduledExecutorGetStatsFromMemberCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.lastIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalRuns)); + assertTrue(isEqual(aLong, parameters.totalRunTimeNanos)); + assertTrue(isEqual(aLong, parameters.lastRunDurationNanos)); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 703; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 704; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 705; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 706; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 707; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeRequest(aString, aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 708; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 709; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeRequest(aString, aString, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 710; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 711; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 712; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 713; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 714; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 715; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 716; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 717; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 718; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 719; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 720; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ScheduledExecutorGetResultFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 721; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 722; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ScheduledExecutorGetResultFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 723; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 724; + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 725; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 726; + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 727; + ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeRequest(aString, aString, null, aBoolean, anInt, anInt, aBoolean, null, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 728; + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_encodeRequest() { + int fileClientMessageIndex = 729; + ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeRequest(aString, anInt, anInt, anInt, anInt, aString, null, null, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_decodeResponse() { + int fileClientMessageIndex = 730; + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 731; + ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeRequest(aString, anInt, anInt, null, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 732; + } + + @Test + public void test_DynamicConfigAddListConfigCodec_encodeRequest() { + int fileClientMessageIndex = 733; + ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeRequest(aString, null, anInt, anInt, anInt, aBoolean, null, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_decodeResponse() { + int fileClientMessageIndex = 734; + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 735; + ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeRequest(aString, null, anInt, anInt, anInt, aBoolean, null, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_decodeResponse() { + int fileClientMessageIndex = 736; + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 737; + ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeRequest(aString, aString, aBoolean, aBoolean, aString, null, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 738; + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 739; + ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeRequest(aString, aBoolean, aBoolean, aBoolean, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_decodeResponse() { + int fileClientMessageIndex = 740; + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 741; + ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeRequest(aString, anInt, anInt, aBoolean, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 742; + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 743; + ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeRequest(aString, anInt, anInt, anInt, null, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 744; + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 745; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeRequest(aString, anInt, anInt, anInt, null, aString, anInt, aBoolean, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 746; + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_encodeRequest() { + int fileClientMessageIndex = 747; + ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeRequest(aString, null, anInt, anInt, anInt, anInt, aBoolean, null, null, aString, anInt, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_decodeResponse() { + int fileClientMessageIndex = 748; + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 749; + ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeRequest(aString, anInt, anInt, anInt, anInt, null, aBoolean, aString, aString, anInt, aString, null, null, aBoolean, null, null, null, null, null, null, null, null, null, null, null, null, anInt, aBoolean, aDataPersistenceConfig, aTieredStoreConfig, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 750; + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 751; + ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeRequest(aString, null, anInt, aBoolean, aString, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_decodeResponse() { + int fileClientMessageIndex = 752; + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeRequest() { + int fileClientMessageIndex = 753; + ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeRequest(aString, null, null, aBoolean, aBoolean, aBoolean, aBoolean, null, null, null, null, anInt, anInt, aString, null, null, anInt, aBoolean, null, null, null, null, null, null, null, null, null, aDataPersistenceConfig); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeResponse() { + int fileClientMessageIndex = 754; + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 755; + ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeRequest(aString, anInt, aLong, aBoolean, aLong, aLong, anInt, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 756; + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_encodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeRequest(aString, anInt, aBoolean, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeResponse() { + int fileClientMessageIndex = 758; + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_encodeRequest() { + int fileClientMessageIndex = 759; + ClientMessage encoded = DynamicConfigAddDataConnectionConfigCodec.encodeRequest(aString, aString, aBoolean, aMapOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_decodeResponse() { + int fileClientMessageIndex = 760; + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_encodeRequest() { + int fileClientMessageIndex = 761; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeResponse() { + int fileClientMessageIndex = 762; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FlakeIdGeneratorNewIdBatchCodec.ResponseParameters parameters = FlakeIdGeneratorNewIdBatchCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.base)); + assertTrue(isEqual(aLong, parameters.increment)); + assertTrue(isEqual(anInt, parameters.batchSize)); + } + + @Test + public void test_PNCounterGetCodec_encodeRequest() { + int fileClientMessageIndex = 763; + ClientMessage encoded = PNCounterGetCodec.encodeRequest(aString, aListOfUuidToLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeResponse() { + int fileClientMessageIndex = 764; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterGetCodec.ResponseParameters parameters = PNCounterGetCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.value)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(anInt, parameters.replicaCount)); + } + + @Test + public void test_PNCounterAddCodec_encodeRequest() { + int fileClientMessageIndex = 765; + ClientMessage encoded = PNCounterAddCodec.encodeRequest(aString, aLong, aBoolean, aListOfUuidToLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterAddCodec_decodeResponse() { + int fileClientMessageIndex = 766; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterAddCodec.ResponseParameters parameters = PNCounterAddCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.value)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(anInt, parameters.replicaCount)); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_encodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, PNCounterGetConfiguredReplicaCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeRequest() { + int fileClientMessageIndex = 769; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeResponse() { + int fileClientMessageIndex = 770; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPGroupCreateCPGroupCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_encodeRequest() { + int fileClientMessageIndex = 771; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeRequest(aRaftGroupId, aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeResponse() { + int fileClientMessageIndex = 772; + } + + @Test + public void test_CPSessionCreateSessionCodec_encodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeResponse() { + int fileClientMessageIndex = 774; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionCreateSessionCodec.ResponseParameters parameters = CPSessionCreateSessionCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.ttlMillis)); + assertTrue(isEqual(aLong, parameters.heartbeatMillis)); + } + + @Test + public void test_CPSessionCloseSessionCodec_encodeRequest() { + int fileClientMessageIndex = 775; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeResponse() { + int fileClientMessageIndex = 776; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSessionCloseSessionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_encodeRequest() { + int fileClientMessageIndex = 777; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeResponse() { + int fileClientMessageIndex = 778; + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeRequest() { + int fileClientMessageIndex = 779; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeRequest(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeResponse() { + int fileClientMessageIndex = 780; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CPSessionGenerateThreadIdCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCReadMetricsCodec_encodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage encoded = MCReadMetricsCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCReadMetricsCodec.ResponseParameters parameters = MCReadMetricsCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfLongToByteArray, parameters.elements)); + assertTrue(isEqual(aLong, parameters.nextSequence)); + } + + @Test + public void test_MCChangeClusterStateCodec_encodeRequest() { + int fileClientMessageIndex = 783; + ClientMessage encoded = MCChangeClusterStateCodec.encodeRequest(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeResponse() { + int fileClientMessageIndex = 784; + } + + @Test + public void test_MCGetMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 785; + ClientMessage encoded = MCGetMapConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 786; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCGetMapConfigCodec.ResponseParameters parameters = MCGetMapConfigCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.inMemoryFormat)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(anInt, parameters.maxIdleSeconds)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(anInt, parameters.maxSizePolicy)); + assertTrue(isEqual(aBoolean, parameters.readBackupData)); + assertTrue(isEqual(anInt, parameters.evictionPolicy)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(parameters.isGlobalIndexesExists); + assertTrue(isEqual(aListOfIndexConfigs, parameters.globalIndexes)); + } + + @Test + public void test_MCUpdateMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 787; + ClientMessage encoded = MCUpdateMapConfigCodec.encodeRequest(aString, anInt, anInt, anInt, aBoolean, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 788; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeRequest() { + int fileClientMessageIndex = 789; + ClientMessage encoded = MCGetMemberConfigCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMemberConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunGcCodec_encodeRequest() { + int fileClientMessageIndex = 791; + ClientMessage encoded = MCRunGcCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeResponse() { + int fileClientMessageIndex = 792; + } + + @Test + public void test_MCGetThreadDumpCodec_encodeRequest() { + int fileClientMessageIndex = 793; + ClientMessage encoded = MCGetThreadDumpCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeResponse() { + int fileClientMessageIndex = 794; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetThreadDumpCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCShutdownMemberCodec_encodeRequest() { + int fileClientMessageIndex = 795; + ClientMessage encoded = MCShutdownMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeResponse() { + int fileClientMessageIndex = 796; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeRequest() { + int fileClientMessageIndex = 797; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeResponse() { + int fileClientMessageIndex = 798; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeRequest() { + int fileClientMessageIndex = 799; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeResponse() { + int fileClientMessageIndex = 800; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToString, MCGetSystemPropertiesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeRequest() { + int fileClientMessageIndex = 801; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeResponse() { + int fileClientMessageIndex = 802; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MCGetTimedMemberStateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 803; + ClientMessage encoded = MCMatchMCConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 804; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCMatchMCConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCApplyMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 805; + ClientMessage encoded = MCApplyMCConfigCodec.encodeRequest(aString, anInt, aListOfClientBwListEntries); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 806; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 807; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 808; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCGetClusterMetadataCodec.ResponseParameters parameters = MCGetClusterMetadataCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.currentState)); + assertTrue(isEqual(aString, parameters.memberVersion)); + assertTrue(isEqual(null, parameters.jetVersion)); + assertTrue(isEqual(aLong, parameters.clusterTime)); + assertTrue(parameters.isClusterIdExists); + assertTrue(isEqual(aUUID, parameters.clusterId)); + } + + @Test + public void test_MCShutdownClusterCodec_encodeRequest() { + int fileClientMessageIndex = 809; + ClientMessage encoded = MCShutdownClusterCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeResponse() { + int fileClientMessageIndex = 810; + } + + @Test + public void test_MCChangeClusterVersionCodec_encodeRequest() { + int fileClientMessageIndex = 811; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeRequest(aByte, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeResponse() { + int fileClientMessageIndex = 812; + } + + @Test + public void test_MCRunScriptCodec_encodeRequest() { + int fileClientMessageIndex = 813; + ClientMessage encoded = MCRunScriptCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeResponse() { + int fileClientMessageIndex = 814; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MCRunScriptCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunConsoleCommandCodec_encodeRequest() { + int fileClientMessageIndex = 815; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeRequest(null, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCRunConsoleCommandCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_encodeRequest() { + int fileClientMessageIndex = 817; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeRequest(aString, aString, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeResponse() { + int fileClientMessageIndex = 818; + } + + @Test + public void test_MCClearWanQueuesCodec_encodeRequest() { + int fileClientMessageIndex = 819; + ClientMessage encoded = MCClearWanQueuesCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeResponse() { + int fileClientMessageIndex = 820; + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_encodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeRequest(aString, aString, null, aString, anInt, anInt, anInt, anInt, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_decodeResponse() { + int fileClientMessageIndex = 822; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCAddWanBatchPublisherConfigCodec.ResponseParameters parameters = MCAddWanBatchPublisherConfigCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfStrings, parameters.addedPublisherIds)); + assertTrue(isEqual(aListOfStrings, parameters.ignoredPublisherIds)); + } + + @Test + public void test_MCWanSyncMapCodec_encodeRequest() { + int fileClientMessageIndex = 823; + ClientMessage encoded = MCWanSyncMapCodec.encodeRequest(aString, aString, anInt, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeResponse() { + int fileClientMessageIndex = 824; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCWanSyncMapCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCCheckWanConsistencyCodec_encodeRequest() { + int fileClientMessageIndex = 825; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeRequest(aString, aString, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MCCheckWanConsistencyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPollMCEventsCodec_encodeRequest() { + int fileClientMessageIndex = 827; + ClientMessage encoded = MCPollMCEventsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfMCEvents, MCPollMCEventsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetCPMembersCodec_encodeRequest() { + int fileClientMessageIndex = 829; + ClientMessage encoded = MCGetCPMembersCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeResponse() { + int fileClientMessageIndex = 830; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfUUIDToUUID, MCGetCPMembersCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 831; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 832; + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 833; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 834; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeRequest() { + int fileClientMessageIndex = 835; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeResponse() { + int fileClientMessageIndex = 836; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeRequest() { + int fileClientMessageIndex = 837; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeResponse() { + int fileClientMessageIndex = 838; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerPartialStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerForceStartCodec_encodeRequest() { + int fileClientMessageIndex = 839; + ClientMessage encoded = MCTriggerForceStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeResponse() { + int fileClientMessageIndex = 840; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerForceStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 841; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 842; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 843; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 844; + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_encodeRequest() { + int fileClientMessageIndex = 845; + ClientMessage encoded = MCResetQueueAgeStatisticsCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_decodeResponse() { + int fileClientMessageIndex = 846; + } + + @Test + public void test_MCReloadConfigCodec_encodeRequest() { + int fileClientMessageIndex = 847; + ClientMessage encoded = MCReloadConfigCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReloadConfigCodec_decodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCReloadConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCUpdateConfigCodec_encodeRequest() { + int fileClientMessageIndex = 849; + ClientMessage encoded = MCUpdateConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateConfigCodec_decodeResponse() { + int fileClientMessageIndex = 850; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCUpdateConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SqlExecute_reservedCodec_encodeRequest() { + int fileClientMessageIndex = 851; + ClientMessage encoded = SqlExecute_reservedCodec.encodeRequest(aString, aListOfData, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecute_reservedCodec_decodeResponse() { + int fileClientMessageIndex = 852; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecute_reservedCodec.ResponseParameters parameters = SqlExecute_reservedCodec.decodeResponse(fromFile); + assertTrue(isEqual(null, parameters.queryId)); + assertTrue(isEqual(null, parameters.rowMetadata)); + assertTrue(isEqual(null, parameters.rowPage)); + assertTrue(isEqual(aBoolean, parameters.rowPageLast)); + assertTrue(isEqual(aLong, parameters.updateCount)); + assertTrue(isEqual(null, parameters.error)); + } + + @Test + public void test_SqlFetch_reservedCodec_encodeRequest() { + int fileClientMessageIndex = 853; + ClientMessage encoded = SqlFetch_reservedCodec.encodeRequest(anSqlQueryId, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetch_reservedCodec_decodeResponse() { + int fileClientMessageIndex = 854; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetch_reservedCodec.ResponseParameters parameters = SqlFetch_reservedCodec.decodeResponse(fromFile); + assertTrue(isEqual(null, parameters.rowPage)); + assertTrue(isEqual(aBoolean, parameters.rowPageLast)); + assertTrue(isEqual(null, parameters.error)); + } + + @Test + public void test_SqlCloseCodec_encodeRequest() { + int fileClientMessageIndex = 855; + ClientMessage encoded = SqlCloseCodec.encodeRequest(anSqlQueryId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeResponse() { + int fileClientMessageIndex = 856; + } + + @Test + public void test_SqlExecuteCodec_encodeRequest() { + int fileClientMessageIndex = 857; + ClientMessage encoded = SqlExecuteCodec.encodeRequest(aString, aListOfData, aLong, anInt, null, aByte, anSqlQueryId, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeResponse() { + int fileClientMessageIndex = 858; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecuteCodec.ResponseParameters parameters = SqlExecuteCodec.decodeResponse(fromFile); + assertTrue(isEqual(null, parameters.rowMetadata)); + assertTrue(isEqual(null, parameters.rowPage)); + assertTrue(isEqual(aLong, parameters.updateCount)); + assertTrue(isEqual(null, parameters.error)); + assertTrue(parameters.isIsInfiniteRowsExists); + assertTrue(isEqual(aBoolean, parameters.isInfiniteRows)); + assertTrue(parameters.isPartitionArgumentIndexExists); + assertTrue(isEqual(anInt, parameters.partitionArgumentIndex)); + } + + @Test + public void test_SqlFetchCodec_encodeRequest() { + int fileClientMessageIndex = 859; + ClientMessage encoded = SqlFetchCodec.encodeRequest(anSqlQueryId, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeResponse() { + int fileClientMessageIndex = 860; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetchCodec.ResponseParameters parameters = SqlFetchCodec.decodeResponse(fromFile); + assertTrue(isEqual(null, parameters.rowPage)); + assertTrue(isEqual(null, parameters.error)); + } + + @Test + public void test_SqlMappingDdlCodec_encodeRequest() { + int fileClientMessageIndex = 861; + ClientMessage encoded = SqlMappingDdlCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlMappingDdlCodec_decodeResponse() { + int fileClientMessageIndex = 862; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, SqlMappingDdlCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 863; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 864; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemAddMembershipListenerCodec.decodeResponse(fromFile))); + } + + private static class CPSubsystemAddMembershipListenerCodecHandler extends CPSubsystemAddMembershipListenerCodec.AbstractEventHandler { + @Override + public void handleMembershipEventEvent(com.hazelcast.cp.CPMember member, byte type) { + assertTrue(isEqual(aCpMember, member)); + assertTrue(isEqual(aByte, type)); + } + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_handleMembershipEventEvent() { + int fileClientMessageIndex = 865; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddMembershipListenerCodecHandler handler = new CPSubsystemAddMembershipListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 866; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 867; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveMembershipListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 868; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 869; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemAddGroupAvailabilityListenerCodec.decodeResponse(fromFile))); + } + + private static class CPSubsystemAddGroupAvailabilityListenerCodecHandler extends CPSubsystemAddGroupAvailabilityListenerCodec.AbstractEventHandler { + @Override + public void handleGroupAvailabilityEventEvent(com.hazelcast.cp.internal.RaftGroupId groupId, java.util.Collection members, java.util.Collection unavailableMembers) { + assertTrue(isEqual(aRaftGroupId, groupId)); + assertTrue(isEqual(aListOfCpMembers, members)); + assertTrue(isEqual(aListOfCpMembers, unavailableMembers)); + } + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_handleGroupAvailabilityEventEvent() { + int fileClientMessageIndex = 870; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddGroupAvailabilityListenerCodecHandler handler = new CPSubsystemAddGroupAvailabilityListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 871; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 872; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExperimentalAuthenticationCodec_encodeRequest() { + int fileClientMessageIndex = 873; + ClientMessage encoded = ExperimentalAuthenticationCodec.encodeRequest(aString, null, null, null, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCodec_decodeResponse() { + int fileClientMessageIndex = 874; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCodec.ResponseParameters parameters = ExperimentalAuthenticationCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(null, parameters.address)); + assertTrue(isEqual(null, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + assertTrue(isEqual(null, parameters.tpcPorts)); + assertTrue(isEqual(null, parameters.tpcToken)); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_encodeRequest() { + int fileClientMessageIndex = 875; + ClientMessage encoded = ExperimentalAuthenticationCustomCodec.encodeRequest(aString, aByteArray, null, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_decodeResponse() { + int fileClientMessageIndex = 876; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCustomCodec.ResponseParameters parameters = ExperimentalAuthenticationCustomCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(null, parameters.address)); + assertTrue(isEqual(null, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + assertTrue(isEqual(null, parameters.tpcPorts)); + assertTrue(isEqual(null, parameters.tpcToken)); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_encodeRequest() { + int fileClientMessageIndex = 877; + ClientMessage encoded = ExperimentalTpcAuthenticationCodec.encodeRequest(aUUID, aByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_decodeResponse() { + int fileClientMessageIndex = 878; + } + + @Test + public void test_JetSubmitJobCodec_encodeRequest() { + int fileClientMessageIndex = 879; + ClientMessage encoded = JetSubmitJobCodec.encodeRequest(aLong, aData, null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetSubmitJobCodec_decodeResponse() { + int fileClientMessageIndex = 880; + } + + @Test + public void test_JetTerminateJobCodec_encodeRequest() { + int fileClientMessageIndex = 881; + ClientMessage encoded = JetTerminateJobCodec.encodeRequest(aLong, anInt, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetTerminateJobCodec_decodeResponse() { + int fileClientMessageIndex = 882; + } + + @Test + public void test_JetGetJobStatusCodec_encodeRequest() { + int fileClientMessageIndex = 883; + ClientMessage encoded = JetGetJobStatusCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobStatusCodec_decodeResponse() { + int fileClientMessageIndex = 884; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, JetGetJobStatusCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobIdsCodec_encodeRequest() { + int fileClientMessageIndex = 885; + ClientMessage encoded = JetGetJobIdsCodec.encodeRequest(null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobIdsCodec_decodeResponse() { + int fileClientMessageIndex = 886; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobIdsCodec.ResponseParameters parameters = JetGetJobIdsCodec.decodeResponse(fromFile); + assertTrue(parameters.isResponseExists); + assertTrue(isEqual(aData, parameters.response)); + } + + @Test + public void test_JetJoinSubmittedJobCodec_encodeRequest() { + int fileClientMessageIndex = 887; + ClientMessage encoded = JetJoinSubmittedJobCodec.encodeRequest(aLong, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetJoinSubmittedJobCodec_decodeResponse() { + int fileClientMessageIndex = 888; + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_encodeRequest() { + int fileClientMessageIndex = 889; + ClientMessage encoded = JetGetJobSubmissionTimeCodec.encodeRequest(aLong, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_decodeResponse() { + int fileClientMessageIndex = 890; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobSubmissionTimeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobConfigCodec_encodeRequest() { + int fileClientMessageIndex = 891; + ClientMessage encoded = JetGetJobConfigCodec.encodeRequest(aLong, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobConfigCodec_decodeResponse() { + int fileClientMessageIndex = 892; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetResumeJobCodec_encodeRequest() { + int fileClientMessageIndex = 893; + ClientMessage encoded = JetResumeJobCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetResumeJobCodec_decodeResponse() { + int fileClientMessageIndex = 894; + } + + @Test + public void test_JetExportSnapshotCodec_encodeRequest() { + int fileClientMessageIndex = 895; + ClientMessage encoded = JetExportSnapshotCodec.encodeRequest(aLong, aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExportSnapshotCodec_decodeResponse() { + int fileClientMessageIndex = 896; + } + + @Test + public void test_JetGetJobSummaryListCodec_encodeRequest() { + int fileClientMessageIndex = 897; + ClientMessage encoded = JetGetJobSummaryListCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSummaryListCodec_decodeResponse() { + int fileClientMessageIndex = 898; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobSummaryListCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetExistsDistributedObjectCodec_encodeRequest() { + int fileClientMessageIndex = 899; + ClientMessage encoded = JetExistsDistributedObjectCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExistsDistributedObjectCodec_decodeResponse() { + int fileClientMessageIndex = 900; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, JetExistsDistributedObjectCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobMetricsCodec_encodeRequest() { + int fileClientMessageIndex = 901; + ClientMessage encoded = JetGetJobMetricsCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobMetricsCodec_decodeResponse() { + int fileClientMessageIndex = 902; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobMetricsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_encodeRequest() { + int fileClientMessageIndex = 903; + ClientMessage encoded = JetGetJobSuspensionCauseCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_decodeResponse() { + int fileClientMessageIndex = 904; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobSuspensionCauseCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_encodeRequest() { + int fileClientMessageIndex = 905; + ClientMessage encoded = JetGetJobAndSqlSummaryListCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_decodeResponse() { + int fileClientMessageIndex = 906; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListJobAndSqlSummary, JetGetJobAndSqlSummaryListCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetIsJobUserCancelledCodec_encodeRequest() { + int fileClientMessageIndex = 907; + ClientMessage encoded = JetIsJobUserCancelledCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetIsJobUserCancelledCodec_decodeResponse() { + int fileClientMessageIndex = 908; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, JetIsJobUserCancelledCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetUploadJobMetaDataCodec_encodeRequest() { + int fileClientMessageIndex = 909; + ClientMessage encoded = JetUploadJobMetaDataCodec.encodeRequest(aUUID, aBoolean, aString, aString, null, null, null, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMetaDataCodec_decodeResponse() { + int fileClientMessageIndex = 910; + } + + @Test + public void test_JetUploadJobMultipartCodec_encodeRequest() { + int fileClientMessageIndex = 911; + ClientMessage encoded = JetUploadJobMultipartCodec.encodeRequest(aUUID, anInt, anInt, aByteArray, anInt, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMultipartCodec_decodeResponse() { + int fileClientMessageIndex = 912; + } + + @Test + public void test_JetAddJobStatusListenerCodec_encodeRequest() { + int fileClientMessageIndex = 913; + ClientMessage encoded = JetAddJobStatusListenerCodec.encodeRequest(aLong, null, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetAddJobStatusListenerCodec_decodeResponse() { + int fileClientMessageIndex = 914; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, JetAddJobStatusListenerCodec.decodeResponse(fromFile))); + } + + private static class JetAddJobStatusListenerCodecHandler extends JetAddJobStatusListenerCodec.AbstractEventHandler { + @Override + public void handleJobStatusEvent(long jobId, int previousStatus, int newStatus, java.lang.String description, boolean userRequested) { + assertTrue(isEqual(aLong, jobId)); + assertTrue(isEqual(anInt, previousStatus)); + assertTrue(isEqual(anInt, newStatus)); + assertTrue(isEqual(null, description)); + assertTrue(isEqual(aBoolean, userRequested)); + } + } + + @Test + public void test_JetAddJobStatusListenerCodec_handleJobStatusEvent() { + int fileClientMessageIndex = 915; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetAddJobStatusListenerCodecHandler handler = new JetAddJobStatusListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_encodeRequest() { + int fileClientMessageIndex = 916; + ClientMessage encoded = JetRemoveJobStatusListenerCodec.encodeRequest(aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_decodeResponse() { + int fileClientMessageIndex = 917; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, JetRemoveJobStatusListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetUpdateJobConfigCodec_encodeRequest() { + int fileClientMessageIndex = 918; + ClientMessage encoded = JetUpdateJobConfigCodec.encodeRequest(aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUpdateJobConfigCodec_decodeResponse() { + int fileClientMessageIndex = 919; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetUpdateJobConfigCodec.decodeResponse(fromFile))); + } + + private void compareClientMessages(ClientMessage binaryMessage, ClientMessage encodedMessage) { + ClientMessage.Frame binaryFrame, encodedFrame; + + ClientMessage.ForwardFrameIterator binaryFrameIterator = binaryMessage.frameIterator(); + ClientMessage.ForwardFrameIterator encodedFrameIterator = encodedMessage.frameIterator(); + assertTrue("Client message that is read from the binary file does not have any frames", binaryFrameIterator.hasNext()); + + while (binaryFrameIterator.hasNext()) { + binaryFrame = binaryFrameIterator.next(); + encodedFrame = encodedFrameIterator.next(); + assertNotNull("Encoded client message has less frames.", encodedFrame); + + if (binaryFrame.isEndFrame() && !encodedFrame.isEndFrame()) { + if (encodedFrame.isBeginFrame()) { + HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + encodedFrame = HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + + boolean isFinal = binaryFrameIterator.peekNext() == null; + int flags = isFinal ? encodedFrame.flags | IS_FINAL_FLAG : encodedFrame.flags; + assertArrayEquals("Frames have different contents", binaryFrame.content, Arrays.copyOf(encodedFrame.content, binaryFrame.content.length)); + assertEquals("Frames have different flags", binaryFrame.flags, flags); + } + } +} diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityTest_2_7.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityTest_2_7.java new file mode 100644 index 000000000000..91f7d5368061 --- /dev/null +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityTest_2_7.java @@ -0,0 +1,7269 @@ +/* + * Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved. + * + * Licensed 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 com.hazelcast.client.protocol.compatibility; + +import com.hazelcast.client.HazelcastClientUtil; +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.ClientMessageReader; +import com.hazelcast.client.impl.protocol.codec.*; +import com.hazelcast.test.HazelcastParallelClassRunner; +import com.hazelcast.test.annotation.ParallelJVMTest; +import com.hazelcast.test.annotation.QuickTest; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static com.hazelcast.client.impl.protocol.ClientMessage.IS_FINAL_FLAG; +import static com.hazelcast.client.protocol.compatibility.ReferenceObjects.*; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.fail; + +@RunWith(HazelcastParallelClassRunner.class) +@Category({QuickTest.class, ParallelJVMTest.class}) +public class ClientCompatibilityTest_2_7 { + private final List clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.7.protocol.compatibility.binary").getFile()); + InputStream inputStream = new FileInputStream(file); + byte[] data = new byte[(int) file.length()]; + inputStream.read(data); + ByteBuffer buffer = ByteBuffer.wrap(data); + ClientMessageReader reader = new ClientMessageReader(0); + while (reader.readFrom(buffer, true)) { + clientMessages.add(reader.getClientMessage()); + reader.reset(); + } + } + + @Test + public void test_ClientAuthenticationCodec_encodeRequest() { + int fileClientMessageIndex = 0; + ClientMessage encoded = ClientAuthenticationCodec.encodeRequest(aString, aString, aString, aUUID, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAuthenticationCodec_decodeResponse() { + int fileClientMessageIndex = 1; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCodec.ResponseParameters parameters = ClientAuthenticationCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(anAddress, parameters.address)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + } + + @Test + public void test_ClientAuthenticationCustomCodec_encodeRequest() { + int fileClientMessageIndex = 2; + ClientMessage encoded = ClientAuthenticationCustomCodec.encodeRequest(aString, aByteArray, aUUID, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAuthenticationCustomCodec_decodeResponse() { + int fileClientMessageIndex = 3; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCustomCodec.ResponseParameters parameters = ClientAuthenticationCustomCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(anAddress, parameters.address)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodeRequest() { + int fileClientMessageIndex = 4; + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_decodeResponse() { + int fileClientMessageIndex = 5; + } + + private static class ClientAddClusterViewListenerCodecHandler extends ClientAddClusterViewListenerCodec.AbstractEventHandler { + @Override + public void handleMembersViewEvent(int version, java.util.Collection memberInfos) { + assertTrue(isEqual(anInt, version)); + assertTrue(isEqual(aListOfMemberInfos, memberInfos)); + } + @Override + public void handlePartitionsViewEvent(int version, java.util.Collection>> partitions) { + assertTrue(isEqual(anInt, version)); + assertTrue(isEqual(aListOfUUIDToListOfIntegers, partitions)); + } + } + + @Test + public void test_ClientAddClusterViewListenerCodec_handleMembersViewEvent() { + int fileClientMessageIndex = 6; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddClusterViewListenerCodecHandler handler = new ClientAddClusterViewListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_handlePartitionsViewEvent() { + int fileClientMessageIndex = 7; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddClusterViewListenerCodecHandler handler = new ClientAddClusterViewListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientCreateProxyCodec_encodeRequest() { + int fileClientMessageIndex = 8; + ClientMessage encoded = ClientCreateProxyCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxyCodec_decodeResponse() { + int fileClientMessageIndex = 9; + } + + @Test + public void test_ClientDestroyProxyCodec_encodeRequest() { + int fileClientMessageIndex = 10; + ClientMessage encoded = ClientDestroyProxyCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDestroyProxyCodec_decodeResponse() { + int fileClientMessageIndex = 11; + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 12; + ClientMessage encoded = ClientAddPartitionLostListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 13; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientAddPartitionLostListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientAddPartitionLostListenerCodecHandler extends ClientAddPartitionLostListenerCodec.AbstractEventHandler { + @Override + public void handlePartitionLostEvent(int partitionId, int lostBackupCount, java.util.UUID source) { + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(anInt, lostBackupCount)); + assertTrue(isEqual(aUUID, source)); + } + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_handlePartitionLostEvent() { + int fileClientMessageIndex = 14; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddPartitionLostListenerCodecHandler handler = new ClientAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 15; + ClientMessage encoded = ClientRemovePartitionLostListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 16; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientGetDistributedObjectsCodec_encodeRequest() { + int fileClientMessageIndex = 17; + ClientMessage encoded = ClientGetDistributedObjectsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientGetDistributedObjectsCodec_decodeResponse() { + int fileClientMessageIndex = 18; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDistributedObjectInfo, ClientGetDistributedObjectsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_encodeRequest() { + int fileClientMessageIndex = 19; + ClientMessage encoded = ClientAddDistributedObjectListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_decodeResponse() { + int fileClientMessageIndex = 20; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientAddDistributedObjectListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientAddDistributedObjectListenerCodecHandler extends ClientAddDistributedObjectListenerCodec.AbstractEventHandler { + @Override + public void handleDistributedObjectEvent(java.lang.String name, java.lang.String serviceName, java.lang.String eventType, java.util.UUID source) { + assertTrue(isEqual(aString, name)); + assertTrue(isEqual(aString, serviceName)); + assertTrue(isEqual(aString, eventType)); + assertTrue(isEqual(aUUID, source)); + } + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_handleDistributedObjectEvent() { + int fileClientMessageIndex = 21; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddDistributedObjectListenerCodecHandler handler = new ClientAddDistributedObjectListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_encodeRequest() { + int fileClientMessageIndex = 22; + ClientMessage encoded = ClientRemoveDistributedObjectListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_decodeResponse() { + int fileClientMessageIndex = 23; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientRemoveDistributedObjectListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientPingCodec_encodeRequest() { + int fileClientMessageIndex = 24; + ClientMessage encoded = ClientPingCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientPingCodec_decodeResponse() { + int fileClientMessageIndex = 25; + } + + @Test + public void test_ClientStatisticsCodec_encodeRequest() { + int fileClientMessageIndex = 26; + ClientMessage encoded = ClientStatisticsCodec.encodeRequest(aLong, aString, aByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientStatisticsCodec_decodeResponse() { + int fileClientMessageIndex = 27; + } + + @Test + public void test_ClientDeployClassesCodec_encodeRequest() { + int fileClientMessageIndex = 28; + ClientMessage encoded = ClientDeployClassesCodec.encodeRequest(aListOfStringToByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDeployClassesCodec_decodeResponse() { + int fileClientMessageIndex = 29; + } + + @Test + public void test_ClientCreateProxiesCodec_encodeRequest() { + int fileClientMessageIndex = 30; + ClientMessage encoded = ClientCreateProxiesCodec.encodeRequest(aListOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxiesCodec_decodeResponse() { + int fileClientMessageIndex = 31; + } + + @Test + public void test_ClientLocalBackupListenerCodec_encodeRequest() { + int fileClientMessageIndex = 32; + ClientMessage encoded = ClientLocalBackupListenerCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientLocalBackupListenerCodec_decodeResponse() { + int fileClientMessageIndex = 33; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientLocalBackupListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientLocalBackupListenerCodecHandler extends ClientLocalBackupListenerCodec.AbstractEventHandler { + @Override + public void handleBackupEvent(long sourceInvocationCorrelationId) { + assertTrue(isEqual(aLong, sourceInvocationCorrelationId)); + } + } + + @Test + public void test_ClientLocalBackupListenerCodec_handleBackupEvent() { + int fileClientMessageIndex = 34; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientLocalBackupListenerCodecHandler handler = new ClientLocalBackupListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_encodeRequest() { + int fileClientMessageIndex = 35; + ClientMessage encoded = ClientTriggerPartitionAssignmentCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_decodeResponse() { + int fileClientMessageIndex = 36; + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 37; + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 38; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientAddMigrationListenerCodec.decodeResponse(fromFile))); + } + + private static class ClientAddMigrationListenerCodecHandler extends ClientAddMigrationListenerCodec.AbstractEventHandler { + @Override + public void handleMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int type) { + assertTrue(isEqual(aMigrationState, migrationState)); + assertTrue(isEqual(anInt, type)); + } + @Override + public void handleReplicaMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId, int replicaIndex, java.util.UUID sourceUuid, java.util.UUID destUuid, boolean success, long elapsedTime) { + assertTrue(isEqual(aMigrationState, migrationState)); + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(anInt, replicaIndex)); + assertTrue(isEqual(aUUID, sourceUuid)); + assertTrue(isEqual(aUUID, destUuid)); + assertTrue(isEqual(aBoolean, success)); + assertTrue(isEqual(aLong, elapsedTime)); + } + } + + @Test + public void test_ClientAddMigrationListenerCodec_handleMigrationEvent() { + int fileClientMessageIndex = 39; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddMigrationListenerCodecHandler handler = new ClientAddMigrationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientAddMigrationListenerCodec_handleReplicaMigrationEvent() { + int fileClientMessageIndex = 40; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAddMigrationListenerCodecHandler handler = new ClientAddMigrationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 41; + ClientMessage encoded = ClientRemoveMigrationListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 42; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientRemoveMigrationListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientSendSchemaCodec_encodeRequest() { + int fileClientMessageIndex = 43; + ClientMessage encoded = ClientSendSchemaCodec.encodeRequest(aSchema); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendSchemaCodec_decodeResponse() { + int fileClientMessageIndex = 44; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aSetOfUUIDs, ClientSendSchemaCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientFetchSchemaCodec_encodeRequest() { + int fileClientMessageIndex = 45; + ClientMessage encoded = ClientFetchSchemaCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientFetchSchemaCodec_decodeResponse() { + int fileClientMessageIndex = 46; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aSchema, ClientFetchSchemaCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ClientSendAllSchemasCodec_encodeRequest() { + int fileClientMessageIndex = 47; + ClientMessage encoded = ClientSendAllSchemasCodec.encodeRequest(aListOfSchemas); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendAllSchemasCodec_decodeResponse() { + int fileClientMessageIndex = 48; + } + + @Test + public void test_MapPutCodec_encodeRequest() { + int fileClientMessageIndex = 49; + ClientMessage encoded = MapPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutCodec_decodeResponse() { + int fileClientMessageIndex = 50; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetCodec_encodeRequest() { + int fileClientMessageIndex = 51; + ClientMessage encoded = MapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeResponse() { + int fileClientMessageIndex = 52; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 53; + ClientMessage encoded = MapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 54; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 55; + ClientMessage encoded = MapReplaceCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 56; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 57; + ClientMessage encoded = MapReplaceIfSameCodec.encodeRequest(aString, aData, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 58; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 59; + ClientMessage encoded = MapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 60; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage encoded = MapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 62; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 63; + ClientMessage encoded = MapRemoveIfSameCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 64; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 65; + ClientMessage encoded = MapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 66; + } + + @Test + public void test_MapFlushCodec_encodeRequest() { + int fileClientMessageIndex = 67; + ClientMessage encoded = MapFlushCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeResponse() { + int fileClientMessageIndex = 68; + } + + @Test + public void test_MapTryRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 69; + ClientMessage encoded = MapTryRemoveCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 70; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapTryPutCodec_encodeRequest() { + int fileClientMessageIndex = 71; + ClientMessage encoded = MapTryPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryPutCodec_decodeResponse() { + int fileClientMessageIndex = 72; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientCodec_encodeRequest() { + int fileClientMessageIndex = 73; + ClientMessage encoded = MapPutTransientCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientCodec_decodeResponse() { + int fileClientMessageIndex = 74; + } + + @Test + public void test_MapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 75; + ClientMessage encoded = MapPutIfAbsentCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentCodec_decodeResponse() { + int fileClientMessageIndex = 76; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetCodec_encodeRequest() { + int fileClientMessageIndex = 77; + ClientMessage encoded = MapSetCodec.encodeRequest(aString, aData, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetCodec_decodeResponse() { + int fileClientMessageIndex = 78; + } + + @Test + public void test_MapLockCodec_encodeRequest() { + int fileClientMessageIndex = 79; + ClientMessage encoded = MapLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLockCodec_decodeResponse() { + int fileClientMessageIndex = 80; + } + + @Test + public void test_MapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 81; + ClientMessage encoded = MapTryLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryLockCodec_decodeResponse() { + int fileClientMessageIndex = 82; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 83; + ClientMessage encoded = MapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 84; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 85; + ClientMessage encoded = MapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 86; + } + + @Test + public void test_MapAddInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 87; + ClientMessage encoded = MapAddInterceptorCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 88; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapAddInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 89; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 90; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 91; + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 92; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerToKeyWithPredicateCodecHandler extends MapAddEntryListenerToKeyWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 93; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyWithPredicateCodecHandler handler = new MapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 94; + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 95; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerWithPredicateCodecHandler extends MapAddEntryListenerWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 96; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerWithPredicateCodecHandler handler = new MapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 97; + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 98; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerToKeyCodecHandler extends MapAddEntryListenerToKeyCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { + int fileClientMessageIndex = 99; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyCodecHandler handler = new MapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 100; + ClientMessage encoded = MapAddEntryListenerCodec.encodeRequest(aString, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 101; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class MapAddEntryListenerCodecHandler extends MapAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MapAddEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 102; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerCodecHandler handler = new MapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 103; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 104; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 105; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 106; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddPartitionLostListenerCodec.decodeResponse(fromFile))); + } + + private static class MapAddPartitionLostListenerCodecHandler extends MapAddPartitionLostListenerCodec.AbstractEventHandler { + @Override + public void handleMapPartitionLostEvent(int partitionId, java.util.UUID uuid) { + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(aUUID, uuid)); + } + } + + @Test + public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() { + int fileClientMessageIndex = 107; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddPartitionLostListenerCodecHandler handler = new MapAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 109; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetEntryViewCodec_encodeRequest() { + int fileClientMessageIndex = 110; + ClientMessage encoded = MapGetEntryViewCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeResponse() { + int fileClientMessageIndex = 111; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetEntryViewCodec.ResponseParameters parameters = MapGetEntryViewCodec.decodeResponse(fromFile); + assertTrue(isEqual(aSimpleEntryView, parameters.response)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapEvictCodec_encodeRequest() { + int fileClientMessageIndex = 112; + ClientMessage encoded = MapEvictCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeResponse() { + int fileClientMessageIndex = 113; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapEvictCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage encoded = MapEvictAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeResponse() { + int fileClientMessageIndex = 115; + } + + @Test + public void test_MapLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 116; + ClientMessage encoded = MapLoadAllCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 117; + } + + @Test + public void test_MapLoadGivenKeysCodec_encodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeResponse() { + int fileClientMessageIndex = 119; + } + + @Test + public void test_MapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage encoded = MapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 122; + ClientMessage encoded = MapGetAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 123; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 124; + ClientMessage encoded = MapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 125; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 126; + ClientMessage encoded = MapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 127; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 128; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 129; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntriesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntriesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddIndexCodec_encodeRequest() { + int fileClientMessageIndex = 134; + ClientMessage encoded = MapAddIndexCodec.encodeRequest(aString, anIndexConfig); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeResponse() { + int fileClientMessageIndex = 135; + } + + @Test + public void test_MapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage encoded = MapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 137; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 138; + ClientMessage encoded = MapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 139; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 140; + ClientMessage encoded = MapPutAllCodec.encodeRequest(aString, aListOfDataToData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 141; + } + + @Test + public void test_MapClearCodec_encodeRequest() { + int fileClientMessageIndex = 142; + ClientMessage encoded = MapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeResponse() { + int fileClientMessageIndex = 143; + } + + @Test + public void test_MapExecuteOnKeyCodec_encodeRequest() { + int fileClientMessageIndex = 144; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeResponse() { + int fileClientMessageIndex = 145; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapExecuteOnKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSubmitToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 146; + ClientMessage encoded = MapSubmitToKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 147; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapSubmitToKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 148; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 149; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnAllKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 150; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 151; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnKeysCodec_encodeRequest() { + int fileClientMessageIndex = 152; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeRequest(aString, aData, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeResponse() { + int fileClientMessageIndex = 153; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 154; + ClientMessage encoded = MapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 155; + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 156; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 157; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapKeySetWithPagingPredicateCodec.ResponseParameters parameters = MapKeySetWithPagingPredicateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfData, parameters.response)); + assertTrue(isEqual(anAnchorDataListHolder, parameters.anchorDataList)); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 158; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 159; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapValuesWithPagingPredicateCodec.ResponseParameters parameters = MapValuesWithPagingPredicateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfData, parameters.response)); + assertTrue(isEqual(anAnchorDataListHolder, parameters.anchorDataList)); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 160; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 161; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEntriesWithPagingPredicateCodec.ResponseParameters parameters = MapEntriesWithPagingPredicateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfDataToData, parameters.response)); + assertTrue(isEqual(anAnchorDataListHolder, parameters.anchorDataList)); + } + + @Test + public void test_MapFetchKeysCodec_encodeRequest() { + int fileClientMessageIndex = 162; + ClientMessage encoded = MapFetchKeysCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeResponse() { + int fileClientMessageIndex = 163; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchKeysCodec.ResponseParameters parameters = MapFetchKeysCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_MapFetchEntriesCodec_encodeRequest() { + int fileClientMessageIndex = 164; + ClientMessage encoded = MapFetchEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 165; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchEntriesCodec.ResponseParameters parameters = MapFetchEntriesCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + } + + @Test + public void test_MapAggregateCodec_encodeRequest() { + int fileClientMessageIndex = 166; + ClientMessage encoded = MapAggregateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeResponse() { + int fileClientMessageIndex = 167; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapAggregateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAggregateWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 168; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 169; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapAggregateWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectCodec_encodeRequest() { + int fileClientMessageIndex = 170; + ClientMessage encoded = MapProjectCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeResponse() { + int fileClientMessageIndex = 171; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 172; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 173; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 174; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 175; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchNearCacheInvalidationMetadataCodec.ResponseParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfStringToListOfIntegerToLong, parameters.namePartitionSequenceList)); + assertTrue(isEqual(aListOfIntegerToUUID, parameters.partitionUuidList)); + } + + @Test + public void test_MapRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 176; + ClientMessage encoded = MapRemoveAllCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 177; + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 178; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeRequest(aString, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 179; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MapAddNearCacheInvalidationListenerCodec.decodeResponse(fromFile))); + } + + private static class MapAddNearCacheInvalidationListenerCodecHandler extends MapAddNearCacheInvalidationListenerCodec.AbstractEventHandler { + @Override + public void handleIMapInvalidationEvent(com.hazelcast.internal.serialization.Data key, java.util.UUID sourceUuid, java.util.UUID partitionUuid, long sequence) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aUUID, sourceUuid)); + assertTrue(isEqual(aUUID, partitionUuid)); + assertTrue(isEqual(aLong, sequence)); + } + @Override + public void handleIMapBatchInvalidationEvent(java.util.Collection keys, java.util.Collection sourceUuids, java.util.Collection partitionUuids, java.util.Collection sequences) { + assertTrue(isEqual(aListOfData, keys)); + assertTrue(isEqual(aListOfUUIDs, sourceUuids)); + assertTrue(isEqual(aListOfUUIDs, partitionUuids)); + assertTrue(isEqual(aListOfLongs, sequences)); + } + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_handleIMapInvalidationEvent() { + int fileClientMessageIndex = 180; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_handleIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 181; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapFetchWithQueryCodec_encodeRequest() { + int fileClientMessageIndex = 182; + ClientMessage encoded = MapFetchWithQueryCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchWithQueryCodec_decodeResponse() { + int fileClientMessageIndex = 183; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchWithQueryCodec.ResponseParameters parameters = MapFetchWithQueryCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfData, parameters.results)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + } + + @Test + public void test_MapEventJournalSubscribeCodec_encodeRequest() { + int fileClientMessageIndex = 184; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 185; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEventJournalSubscribeCodec.ResponseParameters parameters = MapEventJournalSubscribeCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.oldestSequence)); + assertTrue(isEqual(aLong, parameters.newestSequence)); + } + + @Test + public void test_MapEventJournalReadCodec_encodeRequest() { + int fileClientMessageIndex = 186; + ClientMessage encoded = MapEventJournalReadCodec.encodeRequest(aString, aLong, anInt, anInt, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalReadCodec_decodeResponse() { + int fileClientMessageIndex = 187; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEventJournalReadCodec.ResponseParameters parameters = MapEventJournalReadCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.readCount)); + assertTrue(isEqual(aListOfData, parameters.items)); + assertTrue(isEqual(aLongArray, parameters.itemSeqs)); + assertTrue(isEqual(aLong, parameters.nextSeq)); + } + + @Test + public void test_MapSetTtlCodec_encodeRequest() { + int fileClientMessageIndex = 188; + ClientMessage encoded = MapSetTtlCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeResponse() { + int fileClientMessageIndex = 189; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapSetTtlCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 190; + ClientMessage encoded = MapPutWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 191; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 192; + ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 193; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutTransientWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 194; + ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 195; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutIfAbsentWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 196; + ClientMessage encoded = MapSetWithMaxIdleCodec.encodeRequest(aString, aData, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetWithMaxIdleCodec_decodeResponse() { + int fileClientMessageIndex = 197; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapSetWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceAllCodec_encodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage encoded = MapReplaceAllCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceAllCodec_decodeResponse() { + int fileClientMessageIndex = 199; + } + + @Test + public void test_MapPutAllWithMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage encoded = MapPutAllWithMetadataCodec.encodeRequest(aString, aListOfSimpleEntryViews); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllWithMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 201; + } + + @Test + public void test_MultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage encoded = MultiMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 204; + ClientMessage encoded = MultiMapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 205; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 206; + ClientMessage encoded = MultiMapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 207; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 208; + ClientMessage encoded = MultiMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 209; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage encoded = MultiMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage encoded = MultiMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 213; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MultiMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 214; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 215; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 216; + ClientMessage encoded = MultiMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 217; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsEntryCodec_encodeRequest() { + int fileClientMessageIndex = 218; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeResponse() { + int fileClientMessageIndex = 219; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 220; + ClientMessage encoded = MultiMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 221; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 222; + ClientMessage encoded = MultiMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 223; + } + + @Test + public void test_MultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 224; + ClientMessage encoded = MultiMapValueCountCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 225; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 226; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 227; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MultiMapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); + } + + private static class MultiMapAddEntryListenerToKeyCodecHandler extends MultiMapAddEntryListenerToKeyCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_handleEntryEvent() { + int fileClientMessageIndex = 228; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerToKeyCodecHandler handler = new MultiMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 229; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 230; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MultiMapAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class MultiMapAddEntryListenerCodecHandler extends MultiMapAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_MultiMapAddEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 231; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerCodecHandler handler = new MultiMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 232; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 233; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapLockCodec_encodeRequest() { + int fileClientMessageIndex = 234; + ClientMessage encoded = MultiMapLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapLockCodec_decodeResponse() { + int fileClientMessageIndex = 235; + } + + @Test + public void test_MultiMapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 236; + ClientMessage encoded = MultiMapTryLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapTryLockCodec_decodeResponse() { + int fileClientMessageIndex = 237; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 238; + ClientMessage encoded = MultiMapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 239; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 240; + ClientMessage encoded = MultiMapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 241; + } + + @Test + public void test_MultiMapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 242; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 243; + } + + @Test + public void test_MultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 246; + ClientMessage encoded = MultiMapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 247; + } + + @Test + public void test_MultiMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 248; + ClientMessage encoded = MultiMapPutAllCodec.encodeRequest(aString, aListOfDataToListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 249; + } + + @Test + public void test_QueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage encoded = QueueOfferCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePutCodec_encodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage encoded = QueuePutCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeResponse() { + int fileClientMessageIndex = 253; + } + + @Test + public void test_QueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage encoded = QueueSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage encoded = QueueRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 258; + ClientMessage encoded = QueuePollCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 259; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, QueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 260; + ClientMessage encoded = QueueTakeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 261; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, QueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 262; + ClientMessage encoded = QueuePeekCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 263; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, QueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 264; + ClientMessage encoded = QueueIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 265; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeRequest() { + int fileClientMessageIndex = 266; + ClientMessage encoded = QueueDrainToCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeResponse() { + int fileClientMessageIndex = 267; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_encodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeResponse() { + int fileClientMessageIndex = 269; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToMaxSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsCodec_encodeRequest() { + int fileClientMessageIndex = 270; + ClientMessage encoded = QueueContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeResponse() { + int fileClientMessageIndex = 271; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 272; + ClientMessage encoded = QueueContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 273; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 274; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 275; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 276; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 277; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeRequest() { + int fileClientMessageIndex = 278; + ClientMessage encoded = QueueClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeResponse() { + int fileClientMessageIndex = 279; + } + + @Test + public void test_QueueAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 280; + ClientMessage encoded = QueueAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 281; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 282; + ClientMessage encoded = QueueAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 283; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, QueueAddListenerCodec.decodeResponse(fromFile))); + } + + private static class QueueAddListenerCodecHandler extends QueueAddListenerCodec.AbstractEventHandler { + @Override + public void handleItemEvent(com.hazelcast.internal.serialization.Data item, java.util.UUID uuid, int eventType) { + assertTrue(isEqual(aData, item)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, eventType)); + } + } + + @Test + public void test_QueueAddListenerCodec_handleItemEvent() { + int fileClientMessageIndex = 284; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddListenerCodecHandler handler = new QueueAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_QueueRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 285; + ClientMessage encoded = QueueRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 286; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 287; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 288; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 289; + ClientMessage encoded = QueueIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 290; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishCodec_encodeRequest() { + int fileClientMessageIndex = 291; + ClientMessage encoded = TopicPublishCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeResponse() { + int fileClientMessageIndex = 292; + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 293; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 294; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, TopicAddMessageListenerCodec.decodeResponse(fromFile))); + } + + private static class TopicAddMessageListenerCodecHandler extends TopicAddMessageListenerCodec.AbstractEventHandler { + @Override + public void handleTopicEvent(com.hazelcast.internal.serialization.Data item, long publishTime, java.util.UUID uuid) { + assertTrue(isEqual(aData, item)); + assertTrue(isEqual(aLong, publishTime)); + assertTrue(isEqual(aUUID, uuid)); + } + } + + @Test + public void test_TopicAddMessageListenerCodec_handleTopicEvent() { + int fileClientMessageIndex = 295; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicAddMessageListenerCodecHandler handler = new TopicAddMessageListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 296; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 297; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TopicRemoveMessageListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishAllCodec_encodeRequest() { + int fileClientMessageIndex = 298; + ClientMessage encoded = TopicPublishAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeResponse() { + int fileClientMessageIndex = 299; + } + + @Test + public void test_ListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 300; + ClientMessage encoded = ListSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 301; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsCodec_encodeRequest() { + int fileClientMessageIndex = 302; + ClientMessage encoded = ListContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeResponse() { + int fileClientMessageIndex = 303; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 304; + ClientMessage encoded = ListContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 305; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddCodec_encodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage encoded = ListAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeResponse() { + int fileClientMessageIndex = 307; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage encoded = ListRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 310; + ClientMessage encoded = ListAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 311; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 312; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 313; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 314; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 315; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeRequest() { + int fileClientMessageIndex = 316; + ClientMessage encoded = ListClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeResponse() { + int fileClientMessageIndex = 317; + } + + @Test + public void test_ListGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 318; + ClientMessage encoded = ListGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 319; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 320; + ClientMessage encoded = ListAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 321; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ListAddListenerCodec.decodeResponse(fromFile))); + } + + private static class ListAddListenerCodecHandler extends ListAddListenerCodec.AbstractEventHandler { + @Override + public void handleItemEvent(com.hazelcast.internal.serialization.Data item, java.util.UUID uuid, int eventType) { + assertTrue(isEqual(aData, item)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, eventType)); + } + } + + @Test + public void test_ListAddListenerCodec_handleItemEvent() { + int fileClientMessageIndex = 322; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddListenerCodecHandler handler = new ListAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ListRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 323; + ClientMessage encoded = ListRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 324; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 325; + ClientMessage encoded = ListIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 326; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 327; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeRequest(aString, anInt, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 328; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListGetCodec_encodeRequest() { + int fileClientMessageIndex = 329; + ClientMessage encoded = ListGetCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeResponse() { + int fileClientMessageIndex = 330; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ListGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSetCodec_encodeRequest() { + int fileClientMessageIndex = 331; + ClientMessage encoded = ListSetCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeResponse() { + int fileClientMessageIndex = 332; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ListSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage encoded = ListAddWithIndexCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 334; + } + + @Test + public void test_ListRemoveWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 335; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 336; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ListRemoveWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListLastIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage encoded = ListLastIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListLastIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 339; + ClientMessage encoded = ListIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 340; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSubCodec_encodeRequest() { + int fileClientMessageIndex = 341; + ClientMessage encoded = ListSubCodec.encodeRequest(aString, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeResponse() { + int fileClientMessageIndex = 342; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListSubCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 343; + ClientMessage encoded = ListIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 344; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 345; + ClientMessage encoded = ListListIteratorCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 346; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 347; + ClientMessage encoded = SetSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 348; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsCodec_encodeRequest() { + int fileClientMessageIndex = 349; + ClientMessage encoded = SetContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeResponse() { + int fileClientMessageIndex = 350; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 351; + ClientMessage encoded = SetContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 352; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddCodec_encodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage encoded = SetAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeResponse() { + int fileClientMessageIndex = 354; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage encoded = SetRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 357; + ClientMessage encoded = SetAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 358; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 359; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 360; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 361; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 362; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeRequest() { + int fileClientMessageIndex = 363; + ClientMessage encoded = SetClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeResponse() { + int fileClientMessageIndex = 364; + } + + @Test + public void test_SetGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 365; + ClientMessage encoded = SetGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 366; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, SetGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 367; + ClientMessage encoded = SetAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 368; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, SetAddListenerCodec.decodeResponse(fromFile))); + } + + private static class SetAddListenerCodecHandler extends SetAddListenerCodec.AbstractEventHandler { + @Override + public void handleItemEvent(com.hazelcast.internal.serialization.Data item, java.util.UUID uuid, int eventType) { + assertTrue(isEqual(aData, item)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, eventType)); + } + } + + @Test + public void test_SetAddListenerCodec_handleItemEvent() { + int fileClientMessageIndex = 369; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddListenerCodecHandler handler = new SetAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_SetRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 370; + ClientMessage encoded = SetRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 371; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 372; + ClientMessage encoded = SetIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 373; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockLockCodec_encodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage encoded = FencedLockLockCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockLockCodec_decodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 376; + ClientMessage encoded = FencedLockTryLockCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockTryLockCodec_decodeResponse() { + int fileClientMessageIndex = 377; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 378; + ClientMessage encoded = FencedLockUnlockCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 379; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, FencedLockUnlockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_encodeRequest() { + int fileClientMessageIndex = 380; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeResponse() { + int fileClientMessageIndex = 381; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockGetLockOwnershipCodec.ResponseParameters parameters = FencedLockGetLockOwnershipCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.fence)); + assertTrue(isEqual(anInt, parameters.lockCount)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_ExecutorServiceShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 382; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 383; + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 384; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 385; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 386; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 387; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_encodeRequest() { + int fileClientMessageIndex = 388; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeRequest(aUUID, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeResponse() { + int fileClientMessageIndex = 389; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 390; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeRequest(aString, aUUID, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 391; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ExecutorServiceSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 392; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeRequest(aString, aUUID, aData, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeResponse() { + int fileClientMessageIndex = 393; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ExecutorServiceSubmitToMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongApplyCodec_encodeRequest() { + int fileClientMessageIndex = 394; + ClientMessage encoded = AtomicLongApplyCodec.encodeRequest(aRaftGroupId, aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeResponse() { + int fileClientMessageIndex = 395; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicLongApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAlterCodec_encodeRequest() { + int fileClientMessageIndex = 396; + ClientMessage encoded = AtomicLongAlterCodec.encodeRequest(aRaftGroupId, aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeResponse() { + int fileClientMessageIndex = 397; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAlterCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAddAndGetCodec_encodeRequest() { + int fileClientMessageIndex = 398; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeResponse() { + int fileClientMessageIndex = 399; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAddAndGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 400; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 401; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicLongCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetCodec_encodeRequest() { + int fileClientMessageIndex = 402; + ClientMessage encoded = AtomicLongGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeResponse() { + int fileClientMessageIndex = 403; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndAddCodec_encodeRequest() { + int fileClientMessageIndex = 404; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeResponse() { + int fileClientMessageIndex = 405; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 406; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 407; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefApplyCodec_encodeRequest() { + int fileClientMessageIndex = 408; + ClientMessage encoded = AtomicRefApplyCodec.encodeRequest(aRaftGroupId, aString, aData, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefApplyCodec_decodeResponse() { + int fileClientMessageIndex = 409; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicRefApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 410; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 411; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefContainsCodec_encodeRequest() { + int fileClientMessageIndex = 412; + ClientMessage encoded = AtomicRefContainsCodec.encodeRequest(aRaftGroupId, aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeResponse() { + int fileClientMessageIndex = 413; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefGetCodec_encodeRequest() { + int fileClientMessageIndex = 414; + ClientMessage encoded = AtomicRefGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeResponse() { + int fileClientMessageIndex = 415; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicRefGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefSetCodec_encodeRequest() { + int fileClientMessageIndex = 416; + ClientMessage encoded = AtomicRefSetCodec.encodeRequest(aRaftGroupId, aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeResponse() { + int fileClientMessageIndex = 417; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicRefSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_encodeRequest() { + int fileClientMessageIndex = 418; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeResponse() { + int fileClientMessageIndex = 419; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchTrySetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchAwaitCodec_encodeRequest() { + int fileClientMessageIndex = 420; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeRequest(aRaftGroupId, aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeResponse() { + int fileClientMessageIndex = 421; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchAwaitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchCountDownCodec_encodeRequest() { + int fileClientMessageIndex = 422; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeRequest(aRaftGroupId, aString, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeResponse() { + int fileClientMessageIndex = 423; + } + + @Test + public void test_CountDownLatchGetCountCodec_encodeRequest() { + int fileClientMessageIndex = 424; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeResponse() { + int fileClientMessageIndex = 425; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchGetRoundCodec_encodeRequest() { + int fileClientMessageIndex = 426; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeResponse() { + int fileClientMessageIndex = 427; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetRoundCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreInitCodec_encodeRequest() { + int fileClientMessageIndex = 428; + ClientMessage encoded = SemaphoreInitCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeResponse() { + int fileClientMessageIndex = 429; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreInitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAcquireCodec_encodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage encoded = SemaphoreAcquireCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAcquireCodec_decodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreAcquireCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreReleaseCodec_encodeRequest() { + int fileClientMessageIndex = 432; + ClientMessage encoded = SemaphoreReleaseCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreReleaseCodec_decodeResponse() { + int fileClientMessageIndex = 433; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreReleaseCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreDrainCodec_encodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage encoded = SemaphoreDrainCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreDrainCodec_decodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreDrainCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreChangeCodec_encodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage encoded = SemaphoreChangeCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreChangeCodec_decodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreChangeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_encodeRequest() { + int fileClientMessageIndex = 438; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeResponse() { + int fileClientMessageIndex = 439; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreAvailablePermitsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeRequest() { + int fileClientMessageIndex = 440; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeResponse() { + int fileClientMessageIndex = 441; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreGetSemaphoreTypeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 442; + ClientMessage encoded = ReplicatedMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 443; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ReplicatedMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 444; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 445; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ReplicatedMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 446; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 447; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 449; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 450; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 451; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 452; + ClientMessage encoded = ReplicatedMapGetCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 453; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ReplicatedMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 454; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 455; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ReplicatedMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 456; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeRequest(aString, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 457; + } + + @Test + public void test_ReplicatedMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 458; + ClientMessage encoded = ReplicatedMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 459; + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 460; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 461; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler extends ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 462; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 463; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 464; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerWithPredicateCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerWithPredicateCodecHandler extends ReplicatedMapAddEntryListenerWithPredicateCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_handleEntryEvent() { + int fileClientMessageIndex = 465; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerToKeyCodecHandler extends ReplicatedMapAddEntryListenerToKeyCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_handleEntryEvent() { + int fileClientMessageIndex = 468; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 469; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 470; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddEntryListenerCodecHandler extends ReplicatedMapAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 471; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerCodecHandler handler = new ReplicatedMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 472; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 473; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 474; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 475; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 476; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 477; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 478; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 479; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ReplicatedMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 480; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 481; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ReplicatedMapAddNearCacheEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class ReplicatedMapAddNearCacheEntryListenerCodecHandler extends ReplicatedMapAddNearCacheEntryListenerCodec.AbstractEventHandler { + @Override + public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com.hazelcast.internal.serialization.Data value, com.hazelcast.internal.serialization.Data oldValue, com.hazelcast.internal.serialization.Data mergingValue, int eventType, java.util.UUID uuid, int numberOfAffectedEntries) { + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aData, value)); + assertTrue(isEqual(aData, oldValue)); + assertTrue(isEqual(aData, mergingValue)); + assertTrue(isEqual(anInt, eventType)); + assertTrue(isEqual(aUUID, uuid)); + assertTrue(isEqual(anInt, numberOfAffectedEntries)); + } + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_handleEntryEvent() { + int fileClientMessageIndex = 482; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddNearCacheEntryListenerCodecHandler handler = new ReplicatedMapAddNearCacheEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 483; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 484; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 485; + ClientMessage encoded = TransactionalMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 486; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_encodeRequest() { + int fileClientMessageIndex = 487; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeResponse() { + int fileClientMessageIndex = 488; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapGetForUpdateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 489; + ClientMessage encoded = TransactionalMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 490; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 491; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 492; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 493; + ClientMessage encoded = TransactionalMapPutCodec.encodeRequest(aString, aUUID, aLong, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 494; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSetCodec_encodeRequest() { + int fileClientMessageIndex = 495; + ClientMessage encoded = TransactionalMapSetCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSetCodec_decodeResponse() { + int fileClientMessageIndex = 496; + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 497; + ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_decodeResponse() { + int fileClientMessageIndex = 498; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 499; + ClientMessage encoded = TransactionalMapReplaceCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 500; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 501; + ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeRequest(aString, aUUID, aLong, aData, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 502; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 503; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 504; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 505; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 506; + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 507; + ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 508; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 509; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 510; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 511; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 512; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 513; + ClientMessage encoded = TransactionalMapValuesCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 514; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 515; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 516; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 517; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 518; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 519; + ClientMessage encoded = TransactionalMultiMapPutCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 520; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 521; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 522; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 523; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 524; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 525; + ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeRequest(aString, aUUID, aLong, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_decodeResponse() { + int fileClientMessageIndex = 526; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 527; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 528; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 529; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 530; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetAddCodec_encodeRequest() { + int fileClientMessageIndex = 531; + ClientMessage encoded = TransactionalSetAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeResponse() { + int fileClientMessageIndex = 532; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 533; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 534; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 535; + ClientMessage encoded = TransactionalSetSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 536; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalSetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListAddCodec_encodeRequest() { + int fileClientMessageIndex = 537; + ClientMessage encoded = TransactionalListAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeResponse() { + int fileClientMessageIndex = 538; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 539; + ClientMessage encoded = TransactionalListRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 540; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 541; + ClientMessage encoded = TransactionalListSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 542; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 543; + ClientMessage encoded = TransactionalQueueOfferCodec.encodeRequest(aString, aUUID, aLong, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueOfferCodec_decodeResponse() { + int fileClientMessageIndex = 544; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalQueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 545; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 546; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalQueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 547; + ClientMessage encoded = TransactionalQueuePollCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 548; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalQueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 549; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 550; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalQueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 551; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 552; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalQueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 553; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 554; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CacheAddEntryListenerCodec.decodeResponse(fromFile))); + } + + private static class CacheAddEntryListenerCodecHandler extends CacheAddEntryListenerCodec.AbstractEventHandler { + @Override + public void handleCacheEvent(int type, java.util.Collection keys, int completionId) { + assertTrue(isEqual(anInt, type)); + assertTrue(isEqual(aListOfCacheEventData, keys)); + assertTrue(isEqual(anInt, completionId)); + } + } + + @Test + public void test_CacheAddEntryListenerCodec_handleCacheEvent() { + int fileClientMessageIndex = 555; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddEntryListenerCodecHandler handler = new CacheAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheClearCodec_encodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage encoded = CacheClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeResponse() { + int fileClientMessageIndex = 557; + } + + @Test + public void test_CacheRemoveAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 558; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 559; + } + + @Test + public void test_CacheRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 560; + ClientMessage encoded = CacheRemoveAllCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 561; + } + + @Test + public void test_CacheContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 562; + ClientMessage encoded = CacheContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 563; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheCreateConfigCodec_encodeRequest() { + int fileClientMessageIndex = 564; + ClientMessage encoded = CacheCreateConfigCodec.encodeRequest(aCacheConfigHolder, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeResponse() { + int fileClientMessageIndex = 565; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aCacheConfigHolder, CacheCreateConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeRequest() { + int fileClientMessageIndex = 566; + ClientMessage encoded = CacheDestroyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeResponse() { + int fileClientMessageIndex = 567; + } + + @Test + public void test_CacheEntryProcessorCodec_encodeRequest() { + int fileClientMessageIndex = 568; + ClientMessage encoded = CacheEntryProcessorCodec.encodeRequest(aString, aData, aData, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEntryProcessorCodec_decodeResponse() { + int fileClientMessageIndex = 569; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheEntryProcessorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 570; + ClientMessage encoded = CacheGetAllCodec.encodeRequest(aString, aListOfData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 571; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, CacheGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 572; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeRequest(aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 573; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheGetAndRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 574; + ClientMessage encoded = CacheGetAndReplaceCodec.encodeRequest(aString, aData, aData, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 575; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheGetAndReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 576; + ClientMessage encoded = CacheGetConfigCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeResponse() { + int fileClientMessageIndex = 577; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aCacheConfigHolder, CacheGetConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetCodec_encodeRequest() { + int fileClientMessageIndex = 578; + ClientMessage encoded = CacheGetCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeResponse() { + int fileClientMessageIndex = 579; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheIterateCodec_encodeRequest() { + int fileClientMessageIndex = 580; + ClientMessage encoded = CacheIterateCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeResponse() { + int fileClientMessageIndex = 581; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateCodec.ResponseParameters parameters = CacheIterateCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_CacheListenerRegistrationCodec_encodeRequest() { + int fileClientMessageIndex = 582; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeRequest(aString, aData, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeResponse() { + int fileClientMessageIndex = 583; + } + + @Test + public void test_CacheLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 584; + ClientMessage encoded = CacheLoadAllCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 585; + } + + @Test + public void test_CacheManagementConfigCodec_encodeRequest() { + int fileClientMessageIndex = 586; + ClientMessage encoded = CacheManagementConfigCodec.encodeRequest(aString, aBoolean, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeResponse() { + int fileClientMessageIndex = 587; + } + + @Test + public void test_CachePutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 588; + ClientMessage encoded = CachePutIfAbsentCodec.encodeRequest(aString, aData, aData, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutIfAbsentCodec_decodeResponse() { + int fileClientMessageIndex = 589; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CachePutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutCodec_encodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage encoded = CachePutCodec.encodeRequest(aString, aData, aData, aData, aBoolean, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutCodec_decodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CachePutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 592; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 593; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 594; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 595; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveInvalidationListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 596; + ClientMessage encoded = CacheRemoveCodec.encodeRequest(aString, aData, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 597; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 598; + ClientMessage encoded = CacheReplaceCodec.encodeRequest(aString, aData, aData, aData, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 599; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeRequest() { + int fileClientMessageIndex = 600; + ClientMessage encoded = CacheSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeResponse() { + int fileClientMessageIndex = 601; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CacheSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 602; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 603; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CacheAddPartitionLostListenerCodec.decodeResponse(fromFile))); + } + + private static class CacheAddPartitionLostListenerCodecHandler extends CacheAddPartitionLostListenerCodec.AbstractEventHandler { + @Override + public void handleCachePartitionLostEvent(int partitionId, java.util.UUID uuid) { + assertTrue(isEqual(anInt, partitionId)); + assertTrue(isEqual(aUUID, uuid)); + } + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_handleCachePartitionLostEvent() { + int fileClientMessageIndex = 604; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddPartitionLostListenerCodecHandler handler = new CacheAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 605; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 606; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutAllCodec_encodeRequest() { + int fileClientMessageIndex = 607; + ClientMessage encoded = CachePutAllCodec.encodeRequest(aString, aListOfDataToData, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeResponse() { + int fileClientMessageIndex = 608; + } + + @Test + public void test_CacheIterateEntriesCodec_encodeRequest() { + int fileClientMessageIndex = 609; + ClientMessage encoded = CacheIterateEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 610; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateEntriesCodec.ResponseParameters parameters = CacheIterateEntriesCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 611; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 612; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CacheAddNearCacheInvalidationListenerCodec.decodeResponse(fromFile))); + } + + private static class CacheAddNearCacheInvalidationListenerCodecHandler extends CacheAddNearCacheInvalidationListenerCodec.AbstractEventHandler { + @Override + public void handleCacheInvalidationEvent(java.lang.String name, com.hazelcast.internal.serialization.Data key, java.util.UUID sourceUuid, java.util.UUID partitionUuid, long sequence) { + assertTrue(isEqual(aString, name)); + assertTrue(isEqual(aData, key)); + assertTrue(isEqual(aUUID, sourceUuid)); + assertTrue(isEqual(aUUID, partitionUuid)); + assertTrue(isEqual(aLong, sequence)); + } + @Override + public void handleCacheBatchInvalidationEvent(java.lang.String name, java.util.Collection keys, java.util.Collection sourceUuids, java.util.Collection partitionUuids, java.util.Collection sequences) { + assertTrue(isEqual(aString, name)); + assertTrue(isEqual(aListOfData, keys)); + assertTrue(isEqual(aListOfUUIDs, sourceUuids)); + assertTrue(isEqual(aListOfUUIDs, partitionUuids)); + assertTrue(isEqual(aListOfLongs, sequences)); + } + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_handleCacheInvalidationEvent() { + int fileClientMessageIndex = 613; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_handleCacheBatchInvalidationEvent() { + int fileClientMessageIndex = 614; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 615; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheFetchNearCacheInvalidationMetadataCodec.ResponseParameters parameters = CacheFetchNearCacheInvalidationMetadataCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfStringToListOfIntegerToLong, parameters.namePartitionSequenceList)); + assertTrue(isEqual(aListOfIntegerToUUID, parameters.partitionUuidList)); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_encodeRequest() { + int fileClientMessageIndex = 617; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 618; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEventJournalSubscribeCodec.ResponseParameters parameters = CacheEventJournalSubscribeCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.oldestSequence)); + assertTrue(isEqual(aLong, parameters.newestSequence)); + } + + @Test + public void test_CacheEventJournalReadCodec_encodeRequest() { + int fileClientMessageIndex = 619; + ClientMessage encoded = CacheEventJournalReadCodec.encodeRequest(aString, aLong, anInt, anInt, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalReadCodec_decodeResponse() { + int fileClientMessageIndex = 620; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEventJournalReadCodec.ResponseParameters parameters = CacheEventJournalReadCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.readCount)); + assertTrue(isEqual(aListOfData, parameters.items)); + assertTrue(isEqual(aLongArray, parameters.itemSeqs)); + assertTrue(isEqual(aLong, parameters.nextSeq)); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_encodeRequest() { + int fileClientMessageIndex = 621; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeRequest(aString, aListOfData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeResponse() { + int fileClientMessageIndex = 622; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheSetExpiryPolicyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeRequest(anXid); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeResponse() { + int fileClientMessageIndex = 624; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeRequest() { + int fileClientMessageIndex = 625; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeResponse() { + int fileClientMessageIndex = 626; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfXids, XATransactionCollectTransactionsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionFinalizeCodec_encodeRequest() { + int fileClientMessageIndex = 627; + ClientMessage encoded = XATransactionFinalizeCodec.encodeRequest(anXid, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeResponse() { + int fileClientMessageIndex = 628; + } + + @Test + public void test_XATransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 629; + ClientMessage encoded = XATransactionCommitCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 630; + } + + @Test + public void test_XATransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 631; + ClientMessage encoded = XATransactionCreateCodec.encodeRequest(anXid, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 632; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeRequest() { + int fileClientMessageIndex = 633; + ClientMessage encoded = XATransactionPrepareCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeResponse() { + int fileClientMessageIndex = 634; + } + + @Test + public void test_XATransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 635; + ClientMessage encoded = XATransactionRollbackCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 636; + } + + @Test + public void test_TransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 637; + ClientMessage encoded = TransactionCommitCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 638; + } + + @Test + public void test_TransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 639; + ClientMessage encoded = TransactionCreateCodec.encodeRequest(aLong, anInt, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 640; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, TransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 641; + ClientMessage encoded = TransactionRollbackCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 642; + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeRequest() { + int fileClientMessageIndex = 643; + ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeRequest(aString, aString, aData, anInt, anInt, aLong, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeResponse() { + int fileClientMessageIndex = 644; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ContinuousQueryPublisherCreateWithValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_encodeRequest() { + int fileClientMessageIndex = 645; + ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeRequest(aString, aString, aData, anInt, anInt, aLong, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_decodeResponse() { + int fileClientMessageIndex = 646; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ContinuousQueryPublisherCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_encodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryMadePublishableCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ContinuousQueryAddListenerCodec.decodeResponse(fromFile))); + } + + private static class ContinuousQueryAddListenerCodecHandler extends ContinuousQueryAddListenerCodec.AbstractEventHandler { + @Override + public void handleQueryCacheSingleEvent(com.hazelcast.map.impl.querycache.event.QueryCacheEventData data) { + assertTrue(isEqual(aQueryCacheEventData, data)); + } + @Override + public void handleQueryCacheBatchEvent(java.util.Collection events, java.lang.String source, int partitionId) { + assertTrue(isEqual(aListOfQueryCacheEventData, events)); + assertTrue(isEqual(aString, source)); + assertTrue(isEqual(anInt, partitionId)); + } + } + + @Test + public void test_ContinuousQueryAddListenerCodec_handleQueryCacheSingleEvent() { + int fileClientMessageIndex = 651; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_handleQueryCacheBatchEvent() { + int fileClientMessageIndex = 652; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_encodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeRequest(aString, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQuerySetReadCursorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_encodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryDestroyCacheCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeRequest() { + int fileClientMessageIndex = 657; + ClientMessage encoded = RingbufferSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeResponse() { + int fileClientMessageIndex = 658; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 659; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 660; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferTailSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 661; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 662; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferHeadSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 663; + ClientMessage encoded = RingbufferCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 664; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 665; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 666; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddCodec_encodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage encoded = RingbufferAddCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadOneCodec_encodeRequest() { + int fileClientMessageIndex = 669; + ClientMessage encoded = RingbufferReadOneCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeResponse() { + int fileClientMessageIndex = 670; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, RingbufferReadOneCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 671; + ClientMessage encoded = RingbufferAddAllCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 672; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadManyCodec_encodeRequest() { + int fileClientMessageIndex = 673; + ClientMessage encoded = RingbufferReadManyCodec.encodeRequest(aString, aLong, anInt, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadManyCodec_decodeResponse() { + int fileClientMessageIndex = 674; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferReadManyCodec.ResponseParameters parameters = RingbufferReadManyCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.readCount)); + assertTrue(isEqual(aListOfData, parameters.items)); + assertTrue(isEqual(aLongArray, parameters.itemSeqs)); + assertTrue(isEqual(aLong, parameters.nextSeq)); + } + + @Test + public void test_DurableExecutorShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 675; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 676; + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 677; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 678; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, DurableExecutorIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, DurableExecutorSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_encodeRequest() { + int fileClientMessageIndex = 681; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeResponse() { + int fileClientMessageIndex = 682; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, DurableExecutorRetrieveResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 683; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 684; + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 685; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 686; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, DurableExecutorRetrieveAndDisposeResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CardinalityEstimatorAddCodec_encodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeResponse() { + int fileClientMessageIndex = 688; + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeRequest() { + int fileClientMessageIndex = 689; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeResponse() { + int fileClientMessageIndex = 690; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CardinalityEstimatorEstimateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 691; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 692; + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 693; + ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeRequest(aString, aByte, aString, aData, aLong, aLong, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 694; + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 695; + ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeRequest(aString, aUUID, aByte, aString, aData, aLong, aLong, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_decodeResponse() { + int fileClientMessageIndex = 696; + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeRequest() { + int fileClientMessageIndex = 697; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeResponse() { + int fileClientMessageIndex = 698; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfScheduledTaskHandler, ScheduledExecutorGetAllScheduledFuturesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 699; + ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 700; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromPartitionCodec.ResponseParameters parameters = ScheduledExecutorGetStatsFromPartitionCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.lastIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalRuns)); + assertTrue(isEqual(aLong, parameters.totalRunTimeNanos)); + assertTrue(isEqual(aLong, parameters.lastRunDurationNanos)); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 701; + ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 702; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromMemberCodec.ResponseParameters parameters = ScheduledExecutorGetStatsFromMemberCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.lastIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalIdleTimeNanos)); + assertTrue(isEqual(aLong, parameters.totalRuns)); + assertTrue(isEqual(aLong, parameters.totalRunTimeNanos)); + assertTrue(isEqual(aLong, parameters.lastRunDurationNanos)); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 703; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 704; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 705; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 706; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 707; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeRequest(aString, aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 708; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 709; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeRequest(aString, aString, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 710; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 711; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 712; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 713; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 714; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 715; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 716; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 717; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 718; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 719; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 720; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ScheduledExecutorGetResultFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 721; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 722; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ScheduledExecutorGetResultFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 723; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 724; + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 725; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 726; + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 727; + ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeRequest(aString, aString, aListOfListenerConfigHolders, aBoolean, anInt, anInt, aBoolean, aString, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 728; + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_encodeRequest() { + int fileClientMessageIndex = 729; + ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeRequest(aString, anInt, anInt, anInt, anInt, aString, aRingbufferStoreConfigHolder, aString, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_decodeResponse() { + int fileClientMessageIndex = 730; + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 731; + ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeRequest(aString, anInt, anInt, aString, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 732; + } + + @Test + public void test_DynamicConfigAddListConfigCodec_encodeRequest() { + int fileClientMessageIndex = 733; + ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeRequest(aString, aListOfListenerConfigHolders, anInt, anInt, anInt, aBoolean, aString, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_decodeResponse() { + int fileClientMessageIndex = 734; + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 735; + ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeRequest(aString, aListOfListenerConfigHolders, anInt, anInt, anInt, aBoolean, aString, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_decodeResponse() { + int fileClientMessageIndex = 736; + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 737; + ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeRequest(aString, aString, aBoolean, aBoolean, aString, aListOfListenerConfigHolders, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 738; + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 739; + ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeRequest(aString, aBoolean, aBoolean, aBoolean, aListOfListenerConfigHolders); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_decodeResponse() { + int fileClientMessageIndex = 740; + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 741; + ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeRequest(aString, anInt, anInt, aBoolean, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 742; + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 743; + ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeRequest(aString, anInt, anInt, anInt, aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 744; + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 745; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeRequest(aString, anInt, anInt, anInt, aString, aString, anInt, aBoolean, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 746; + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_encodeRequest() { + int fileClientMessageIndex = 747; + ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeRequest(aString, aListOfListenerConfigHolders, anInt, anInt, anInt, anInt, aBoolean, aString, aQueueStoreConfigHolder, aString, anInt, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_decodeResponse() { + int fileClientMessageIndex = 748; + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 749; + ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeRequest(aString, anInt, anInt, anInt, anInt, anEvictionConfigHolder, aBoolean, aString, aString, anInt, aString, aListOfListenerConfigHolders, aListOfListenerConfigHolders, aBoolean, aString, aMapStoreConfigHolder, aNearCacheConfigHolder, aWanReplicationRef, aListOfIndexConfigs, aListOfAttributeConfigs, aListOfQueryCacheConfigHolders, aString, aData, aHotRestartConfig, anEventJournalConfig, aMerkleTreeConfig, anInt, aBoolean, aDataPersistenceConfig, aTieredStoreConfig, aListOfPartitioningAttributeConfigs); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 750; + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 751; + ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeRequest(aString, aListOfListenerConfigHolders, anInt, aBoolean, aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_decodeResponse() { + int fileClientMessageIndex = 752; + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeRequest() { + int fileClientMessageIndex = 753; + ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeRequest(aString, aString, aString, aBoolean, aBoolean, aBoolean, aBoolean, aString, aString, aString, aString, anInt, anInt, aString, aString, aString, anInt, aBoolean, aListOfListenerConfigHolders, aString, aTimedExpiryPolicyFactoryConfig, aListOfCacheSimpleEntryListenerConfigs, anEvictionConfigHolder, aWanReplicationRef, anEventJournalConfig, aHotRestartConfig, aMerkleTreeConfig, aDataPersistenceConfig); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeResponse() { + int fileClientMessageIndex = 754; + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 755; + ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeRequest(aString, anInt, aLong, aBoolean, aLong, aLong, anInt, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 756; + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_encodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeRequest(aString, anInt, aBoolean, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeResponse() { + int fileClientMessageIndex = 758; + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_encodeRequest() { + int fileClientMessageIndex = 759; + ClientMessage encoded = DynamicConfigAddDataConnectionConfigCodec.encodeRequest(aString, aString, aBoolean, aMapOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_decodeResponse() { + int fileClientMessageIndex = 760; + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_encodeRequest() { + int fileClientMessageIndex = 761; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeResponse() { + int fileClientMessageIndex = 762; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FlakeIdGeneratorNewIdBatchCodec.ResponseParameters parameters = FlakeIdGeneratorNewIdBatchCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.base)); + assertTrue(isEqual(aLong, parameters.increment)); + assertTrue(isEqual(anInt, parameters.batchSize)); + } + + @Test + public void test_PNCounterGetCodec_encodeRequest() { + int fileClientMessageIndex = 763; + ClientMessage encoded = PNCounterGetCodec.encodeRequest(aString, aListOfUuidToLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeResponse() { + int fileClientMessageIndex = 764; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterGetCodec.ResponseParameters parameters = PNCounterGetCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.value)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(anInt, parameters.replicaCount)); + } + + @Test + public void test_PNCounterAddCodec_encodeRequest() { + int fileClientMessageIndex = 765; + ClientMessage encoded = PNCounterAddCodec.encodeRequest(aString, aLong, aBoolean, aListOfUuidToLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterAddCodec_decodeResponse() { + int fileClientMessageIndex = 766; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterAddCodec.ResponseParameters parameters = PNCounterAddCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.value)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(anInt, parameters.replicaCount)); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_encodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, PNCounterGetConfiguredReplicaCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeRequest() { + int fileClientMessageIndex = 769; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeResponse() { + int fileClientMessageIndex = 770; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPGroupCreateCPGroupCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_encodeRequest() { + int fileClientMessageIndex = 771; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeRequest(aRaftGroupId, aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeResponse() { + int fileClientMessageIndex = 772; + } + + @Test + public void test_CPSessionCreateSessionCodec_encodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeResponse() { + int fileClientMessageIndex = 774; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionCreateSessionCodec.ResponseParameters parameters = CPSessionCreateSessionCodec.decodeResponse(fromFile); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.ttlMillis)); + assertTrue(isEqual(aLong, parameters.heartbeatMillis)); + } + + @Test + public void test_CPSessionCloseSessionCodec_encodeRequest() { + int fileClientMessageIndex = 775; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeResponse() { + int fileClientMessageIndex = 776; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSessionCloseSessionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_encodeRequest() { + int fileClientMessageIndex = 777; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeResponse() { + int fileClientMessageIndex = 778; + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeRequest() { + int fileClientMessageIndex = 779; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeRequest(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeResponse() { + int fileClientMessageIndex = 780; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CPSessionGenerateThreadIdCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCReadMetricsCodec_encodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage encoded = MCReadMetricsCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCReadMetricsCodec.ResponseParameters parameters = MCReadMetricsCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfLongToByteArray, parameters.elements)); + assertTrue(isEqual(aLong, parameters.nextSequence)); + } + + @Test + public void test_MCChangeClusterStateCodec_encodeRequest() { + int fileClientMessageIndex = 783; + ClientMessage encoded = MCChangeClusterStateCodec.encodeRequest(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeResponse() { + int fileClientMessageIndex = 784; + } + + @Test + public void test_MCGetMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 785; + ClientMessage encoded = MCGetMapConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 786; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCGetMapConfigCodec.ResponseParameters parameters = MCGetMapConfigCodec.decodeResponse(fromFile); + assertTrue(isEqual(anInt, parameters.inMemoryFormat)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(anInt, parameters.maxIdleSeconds)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(anInt, parameters.maxSizePolicy)); + assertTrue(isEqual(aBoolean, parameters.readBackupData)); + assertTrue(isEqual(anInt, parameters.evictionPolicy)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(parameters.isGlobalIndexesExists); + assertTrue(isEqual(aListOfIndexConfigs, parameters.globalIndexes)); + } + + @Test + public void test_MCUpdateMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 787; + ClientMessage encoded = MCUpdateMapConfigCodec.encodeRequest(aString, anInt, anInt, anInt, aBoolean, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 788; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeRequest() { + int fileClientMessageIndex = 789; + ClientMessage encoded = MCGetMemberConfigCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMemberConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunGcCodec_encodeRequest() { + int fileClientMessageIndex = 791; + ClientMessage encoded = MCRunGcCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeResponse() { + int fileClientMessageIndex = 792; + } + + @Test + public void test_MCGetThreadDumpCodec_encodeRequest() { + int fileClientMessageIndex = 793; + ClientMessage encoded = MCGetThreadDumpCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeResponse() { + int fileClientMessageIndex = 794; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetThreadDumpCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCShutdownMemberCodec_encodeRequest() { + int fileClientMessageIndex = 795; + ClientMessage encoded = MCShutdownMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeResponse() { + int fileClientMessageIndex = 796; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeRequest() { + int fileClientMessageIndex = 797; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeResponse() { + int fileClientMessageIndex = 798; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeRequest() { + int fileClientMessageIndex = 799; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeResponse() { + int fileClientMessageIndex = 800; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToString, MCGetSystemPropertiesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeRequest() { + int fileClientMessageIndex = 801; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeResponse() { + int fileClientMessageIndex = 802; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetTimedMemberStateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 803; + ClientMessage encoded = MCMatchMCConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 804; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCMatchMCConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCApplyMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 805; + ClientMessage encoded = MCApplyMCConfigCodec.encodeRequest(aString, anInt, aListOfClientBwListEntries); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 806; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 807; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 808; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCGetClusterMetadataCodec.ResponseParameters parameters = MCGetClusterMetadataCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.currentState)); + assertTrue(isEqual(aString, parameters.memberVersion)); + assertTrue(isEqual(aString, parameters.jetVersion)); + assertTrue(isEqual(aLong, parameters.clusterTime)); + assertTrue(parameters.isClusterIdExists); + assertTrue(isEqual(aUUID, parameters.clusterId)); + } + + @Test + public void test_MCShutdownClusterCodec_encodeRequest() { + int fileClientMessageIndex = 809; + ClientMessage encoded = MCShutdownClusterCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeResponse() { + int fileClientMessageIndex = 810; + } + + @Test + public void test_MCChangeClusterVersionCodec_encodeRequest() { + int fileClientMessageIndex = 811; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeRequest(aByte, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeResponse() { + int fileClientMessageIndex = 812; + } + + @Test + public void test_MCRunScriptCodec_encodeRequest() { + int fileClientMessageIndex = 813; + ClientMessage encoded = MCRunScriptCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeResponse() { + int fileClientMessageIndex = 814; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCRunScriptCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunConsoleCommandCodec_encodeRequest() { + int fileClientMessageIndex = 815; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCRunConsoleCommandCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_encodeRequest() { + int fileClientMessageIndex = 817; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeRequest(aString, aString, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeResponse() { + int fileClientMessageIndex = 818; + } + + @Test + public void test_MCClearWanQueuesCodec_encodeRequest() { + int fileClientMessageIndex = 819; + ClientMessage encoded = MCClearWanQueuesCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeResponse() { + int fileClientMessageIndex = 820; + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_encodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeRequest(aString, aString, aString, aString, anInt, anInt, anInt, anInt, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_decodeResponse() { + int fileClientMessageIndex = 822; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCAddWanBatchPublisherConfigCodec.ResponseParameters parameters = MCAddWanBatchPublisherConfigCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfStrings, parameters.addedPublisherIds)); + assertTrue(isEqual(aListOfStrings, parameters.ignoredPublisherIds)); + } + + @Test + public void test_MCWanSyncMapCodec_encodeRequest() { + int fileClientMessageIndex = 823; + ClientMessage encoded = MCWanSyncMapCodec.encodeRequest(aString, aString, anInt, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeResponse() { + int fileClientMessageIndex = 824; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCWanSyncMapCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCCheckWanConsistencyCodec_encodeRequest() { + int fileClientMessageIndex = 825; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeRequest(aString, aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCCheckWanConsistencyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPollMCEventsCodec_encodeRequest() { + int fileClientMessageIndex = 827; + ClientMessage encoded = MCPollMCEventsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfMCEvents, MCPollMCEventsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetCPMembersCodec_encodeRequest() { + int fileClientMessageIndex = 829; + ClientMessage encoded = MCGetCPMembersCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeResponse() { + int fileClientMessageIndex = 830; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfUUIDToUUID, MCGetCPMembersCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 831; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 832; + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 833; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 834; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeRequest() { + int fileClientMessageIndex = 835; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeResponse() { + int fileClientMessageIndex = 836; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeRequest() { + int fileClientMessageIndex = 837; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeResponse() { + int fileClientMessageIndex = 838; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerPartialStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerForceStartCodec_encodeRequest() { + int fileClientMessageIndex = 839; + ClientMessage encoded = MCTriggerForceStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeResponse() { + int fileClientMessageIndex = 840; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerForceStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 841; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 842; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 843; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 844; + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_encodeRequest() { + int fileClientMessageIndex = 845; + ClientMessage encoded = MCResetQueueAgeStatisticsCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_decodeResponse() { + int fileClientMessageIndex = 846; + } + + @Test + public void test_MCReloadConfigCodec_encodeRequest() { + int fileClientMessageIndex = 847; + ClientMessage encoded = MCReloadConfigCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReloadConfigCodec_decodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCReloadConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCUpdateConfigCodec_encodeRequest() { + int fileClientMessageIndex = 849; + ClientMessage encoded = MCUpdateConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateConfigCodec_decodeResponse() { + int fileClientMessageIndex = 850; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCUpdateConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SqlExecute_reservedCodec_encodeRequest() { + int fileClientMessageIndex = 851; + ClientMessage encoded = SqlExecute_reservedCodec.encodeRequest(aString, aListOfData, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecute_reservedCodec_decodeResponse() { + int fileClientMessageIndex = 852; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecute_reservedCodec.ResponseParameters parameters = SqlExecute_reservedCodec.decodeResponse(fromFile); + assertTrue(isEqual(anSqlQueryId, parameters.queryId)); + assertTrue(isEqual(aListOfSqlColumnMetadata, parameters.rowMetadata)); + assertTrue(isEqual(aListOfListOfData, parameters.rowPage)); + assertTrue(isEqual(aBoolean, parameters.rowPageLast)); + assertTrue(isEqual(aLong, parameters.updateCount)); + assertTrue(isEqual(anSqlError, parameters.error)); + } + + @Test + public void test_SqlFetch_reservedCodec_encodeRequest() { + int fileClientMessageIndex = 853; + ClientMessage encoded = SqlFetch_reservedCodec.encodeRequest(anSqlQueryId, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetch_reservedCodec_decodeResponse() { + int fileClientMessageIndex = 854; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetch_reservedCodec.ResponseParameters parameters = SqlFetch_reservedCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfListOfData, parameters.rowPage)); + assertTrue(isEqual(aBoolean, parameters.rowPageLast)); + assertTrue(isEqual(anSqlError, parameters.error)); + } + + @Test + public void test_SqlCloseCodec_encodeRequest() { + int fileClientMessageIndex = 855; + ClientMessage encoded = SqlCloseCodec.encodeRequest(anSqlQueryId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeResponse() { + int fileClientMessageIndex = 856; + } + + @Test + public void test_SqlExecuteCodec_encodeRequest() { + int fileClientMessageIndex = 857; + ClientMessage encoded = SqlExecuteCodec.encodeRequest(aString, aListOfData, aLong, anInt, aString, aByte, anSqlQueryId, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeResponse() { + int fileClientMessageIndex = 858; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecuteCodec.ResponseParameters parameters = SqlExecuteCodec.decodeResponse(fromFile); + assertTrue(isEqual(aListOfSqlColumnMetadata, parameters.rowMetadata)); + assertTrue(isEqual(aSqlPage, parameters.rowPage)); + assertTrue(isEqual(aLong, parameters.updateCount)); + assertTrue(isEqual(anSqlError, parameters.error)); + assertTrue(parameters.isIsInfiniteRowsExists); + assertTrue(isEqual(aBoolean, parameters.isInfiniteRows)); + assertTrue(parameters.isPartitionArgumentIndexExists); + assertTrue(isEqual(anInt, parameters.partitionArgumentIndex)); + } + + @Test + public void test_SqlFetchCodec_encodeRequest() { + int fileClientMessageIndex = 859; + ClientMessage encoded = SqlFetchCodec.encodeRequest(anSqlQueryId, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeResponse() { + int fileClientMessageIndex = 860; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetchCodec.ResponseParameters parameters = SqlFetchCodec.decodeResponse(fromFile); + assertTrue(isEqual(aSqlPage, parameters.rowPage)); + assertTrue(isEqual(anSqlError, parameters.error)); + } + + @Test + public void test_SqlMappingDdlCodec_encodeRequest() { + int fileClientMessageIndex = 861; + ClientMessage encoded = SqlMappingDdlCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlMappingDdlCodec_decodeResponse() { + int fileClientMessageIndex = 862; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SqlMappingDdlCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 863; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 864; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemAddMembershipListenerCodec.decodeResponse(fromFile))); + } + + private static class CPSubsystemAddMembershipListenerCodecHandler extends CPSubsystemAddMembershipListenerCodec.AbstractEventHandler { + @Override + public void handleMembershipEventEvent(com.hazelcast.cp.CPMember member, byte type) { + assertTrue(isEqual(aCpMember, member)); + assertTrue(isEqual(aByte, type)); + } + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_handleMembershipEventEvent() { + int fileClientMessageIndex = 865; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddMembershipListenerCodecHandler handler = new CPSubsystemAddMembershipListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 866; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 867; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveMembershipListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 868; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 869; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemAddGroupAvailabilityListenerCodec.decodeResponse(fromFile))); + } + + private static class CPSubsystemAddGroupAvailabilityListenerCodecHandler extends CPSubsystemAddGroupAvailabilityListenerCodec.AbstractEventHandler { + @Override + public void handleGroupAvailabilityEventEvent(com.hazelcast.cp.internal.RaftGroupId groupId, java.util.Collection members, java.util.Collection unavailableMembers) { + assertTrue(isEqual(aRaftGroupId, groupId)); + assertTrue(isEqual(aListOfCpMembers, members)); + assertTrue(isEqual(aListOfCpMembers, unavailableMembers)); + } + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_handleGroupAvailabilityEventEvent() { + int fileClientMessageIndex = 870; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddGroupAvailabilityListenerCodecHandler handler = new CPSubsystemAddGroupAvailabilityListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 871; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 872; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExperimentalAuthenticationCodec_encodeRequest() { + int fileClientMessageIndex = 873; + ClientMessage encoded = ExperimentalAuthenticationCodec.encodeRequest(aString, aString, aString, aUUID, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCodec_decodeResponse() { + int fileClientMessageIndex = 874; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCodec.ResponseParameters parameters = ExperimentalAuthenticationCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(anAddress, parameters.address)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + assertTrue(isEqual(aListOfIntegers, parameters.tpcPorts)); + assertTrue(isEqual(aByteArray, parameters.tpcToken)); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_encodeRequest() { + int fileClientMessageIndex = 875; + ClientMessage encoded = ExperimentalAuthenticationCustomCodec.encodeRequest(aString, aByteArray, aUUID, aString, aByte, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_decodeResponse() { + int fileClientMessageIndex = 876; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCustomCodec.ResponseParameters parameters = ExperimentalAuthenticationCustomCodec.decodeResponse(fromFile); + assertTrue(isEqual(aByte, parameters.status)); + assertTrue(isEqual(anAddress, parameters.address)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.serverHazelcastVersion)); + assertTrue(isEqual(anInt, parameters.partitionCount)); + assertTrue(isEqual(aUUID, parameters.clusterId)); + assertTrue(isEqual(aBoolean, parameters.failoverSupported)); + assertTrue(isEqual(aListOfIntegers, parameters.tpcPorts)); + assertTrue(isEqual(aByteArray, parameters.tpcToken)); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_encodeRequest() { + int fileClientMessageIndex = 877; + ClientMessage encoded = ExperimentalTpcAuthenticationCodec.encodeRequest(aUUID, aByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_decodeResponse() { + int fileClientMessageIndex = 878; + } + + @Test + public void test_JetSubmitJobCodec_encodeRequest() { + int fileClientMessageIndex = 879; + ClientMessage encoded = JetSubmitJobCodec.encodeRequest(aLong, aData, aData, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetSubmitJobCodec_decodeResponse() { + int fileClientMessageIndex = 880; + } + + @Test + public void test_JetTerminateJobCodec_encodeRequest() { + int fileClientMessageIndex = 881; + ClientMessage encoded = JetTerminateJobCodec.encodeRequest(aLong, anInt, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetTerminateJobCodec_decodeResponse() { + int fileClientMessageIndex = 882; + } + + @Test + public void test_JetGetJobStatusCodec_encodeRequest() { + int fileClientMessageIndex = 883; + ClientMessage encoded = JetGetJobStatusCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobStatusCodec_decodeResponse() { + int fileClientMessageIndex = 884; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, JetGetJobStatusCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobIdsCodec_encodeRequest() { + int fileClientMessageIndex = 885; + ClientMessage encoded = JetGetJobIdsCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobIdsCodec_decodeResponse() { + int fileClientMessageIndex = 886; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobIdsCodec.ResponseParameters parameters = JetGetJobIdsCodec.decodeResponse(fromFile); + assertTrue(parameters.isResponseExists); + assertTrue(isEqual(aData, parameters.response)); + } + + @Test + public void test_JetJoinSubmittedJobCodec_encodeRequest() { + int fileClientMessageIndex = 887; + ClientMessage encoded = JetJoinSubmittedJobCodec.encodeRequest(aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetJoinSubmittedJobCodec_decodeResponse() { + int fileClientMessageIndex = 888; + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_encodeRequest() { + int fileClientMessageIndex = 889; + ClientMessage encoded = JetGetJobSubmissionTimeCodec.encodeRequest(aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_decodeResponse() { + int fileClientMessageIndex = 890; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobSubmissionTimeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobConfigCodec_encodeRequest() { + int fileClientMessageIndex = 891; + ClientMessage encoded = JetGetJobConfigCodec.encodeRequest(aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobConfigCodec_decodeResponse() { + int fileClientMessageIndex = 892; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetResumeJobCodec_encodeRequest() { + int fileClientMessageIndex = 893; + ClientMessage encoded = JetResumeJobCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetResumeJobCodec_decodeResponse() { + int fileClientMessageIndex = 894; + } + + @Test + public void test_JetExportSnapshotCodec_encodeRequest() { + int fileClientMessageIndex = 895; + ClientMessage encoded = JetExportSnapshotCodec.encodeRequest(aLong, aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExportSnapshotCodec_decodeResponse() { + int fileClientMessageIndex = 896; + } + + @Test + public void test_JetGetJobSummaryListCodec_encodeRequest() { + int fileClientMessageIndex = 897; + ClientMessage encoded = JetGetJobSummaryListCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSummaryListCodec_decodeResponse() { + int fileClientMessageIndex = 898; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobSummaryListCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetExistsDistributedObjectCodec_encodeRequest() { + int fileClientMessageIndex = 899; + ClientMessage encoded = JetExistsDistributedObjectCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExistsDistributedObjectCodec_decodeResponse() { + int fileClientMessageIndex = 900; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, JetExistsDistributedObjectCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobMetricsCodec_encodeRequest() { + int fileClientMessageIndex = 901; + ClientMessage encoded = JetGetJobMetricsCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobMetricsCodec_decodeResponse() { + int fileClientMessageIndex = 902; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobMetricsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_encodeRequest() { + int fileClientMessageIndex = 903; + ClientMessage encoded = JetGetJobSuspensionCauseCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_decodeResponse() { + int fileClientMessageIndex = 904; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetGetJobSuspensionCauseCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_encodeRequest() { + int fileClientMessageIndex = 905; + ClientMessage encoded = JetGetJobAndSqlSummaryListCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_decodeResponse() { + int fileClientMessageIndex = 906; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListJobAndSqlSummary, JetGetJobAndSqlSummaryListCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetIsJobUserCancelledCodec_encodeRequest() { + int fileClientMessageIndex = 907; + ClientMessage encoded = JetIsJobUserCancelledCodec.encodeRequest(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetIsJobUserCancelledCodec_decodeResponse() { + int fileClientMessageIndex = 908; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, JetIsJobUserCancelledCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetUploadJobMetaDataCodec_encodeRequest() { + int fileClientMessageIndex = 909; + ClientMessage encoded = JetUploadJobMetaDataCodec.encodeRequest(aUUID, aBoolean, aString, aString, aString, aString, aString, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMetaDataCodec_decodeResponse() { + int fileClientMessageIndex = 910; + } + + @Test + public void test_JetUploadJobMultipartCodec_encodeRequest() { + int fileClientMessageIndex = 911; + ClientMessage encoded = JetUploadJobMultipartCodec.encodeRequest(aUUID, anInt, anInt, aByteArray, anInt, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMultipartCodec_decodeResponse() { + int fileClientMessageIndex = 912; + } + + @Test + public void test_JetAddJobStatusListenerCodec_encodeRequest() { + int fileClientMessageIndex = 913; + ClientMessage encoded = JetAddJobStatusListenerCodec.encodeRequest(aLong, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetAddJobStatusListenerCodec_decodeResponse() { + int fileClientMessageIndex = 914; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, JetAddJobStatusListenerCodec.decodeResponse(fromFile))); + } + + private static class JetAddJobStatusListenerCodecHandler extends JetAddJobStatusListenerCodec.AbstractEventHandler { + @Override + public void handleJobStatusEvent(long jobId, int previousStatus, int newStatus, java.lang.String description, boolean userRequested) { + assertTrue(isEqual(aLong, jobId)); + assertTrue(isEqual(anInt, previousStatus)); + assertTrue(isEqual(anInt, newStatus)); + assertTrue(isEqual(aString, description)); + assertTrue(isEqual(aBoolean, userRequested)); + } + } + + @Test + public void test_JetAddJobStatusListenerCodec_handleJobStatusEvent() { + int fileClientMessageIndex = 915; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetAddJobStatusListenerCodecHandler handler = new JetAddJobStatusListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_encodeRequest() { + int fileClientMessageIndex = 916; + ClientMessage encoded = JetRemoveJobStatusListenerCodec.encodeRequest(aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_decodeResponse() { + int fileClientMessageIndex = 917; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, JetRemoveJobStatusListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_JetUpdateJobConfigCodec_encodeRequest() { + int fileClientMessageIndex = 918; + ClientMessage encoded = JetUpdateJobConfigCodec.encodeRequest(aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUpdateJobConfigCodec_decodeResponse() { + int fileClientMessageIndex = 919; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, JetUpdateJobConfigCodec.decodeResponse(fromFile))); + } + + private void compareClientMessages(ClientMessage binaryMessage, ClientMessage encodedMessage) { + ClientMessage.Frame binaryFrame, encodedFrame; + + ClientMessage.ForwardFrameIterator binaryFrameIterator = binaryMessage.frameIterator(); + ClientMessage.ForwardFrameIterator encodedFrameIterator = encodedMessage.frameIterator(); + assertTrue("Client message that is read from the binary file does not have any frames", binaryFrameIterator.hasNext()); + + while (binaryFrameIterator.hasNext()) { + binaryFrame = binaryFrameIterator.next(); + encodedFrame = encodedFrameIterator.next(); + assertNotNull("Encoded client message has less frames.", encodedFrame); + + if (binaryFrame.isEndFrame() && !encodedFrame.isEndFrame()) { + if (encodedFrame.isBeginFrame()) { + HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + encodedFrame = HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + + boolean isFinal = binaryFrameIterator.peekNext() == null; + int flags = isFinal ? encodedFrame.flags | IS_FINAL_FLAG : encodedFrame.flags; + assertArrayEquals("Frames have different contents", binaryFrame.content, Arrays.copyOf(encodedFrame.content, binaryFrame.content.length)); + assertEquals("Frames have different flags", binaryFrame.flags, flags); + } + } +} diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_7.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_7.java new file mode 100644 index 000000000000..e772483d39e4 --- /dev/null +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_7.java @@ -0,0 +1,8179 @@ +/* + * Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved. + * + * Licensed 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 com.hazelcast.client.protocol.compatibility; + +import com.hazelcast.client.HazelcastClientUtil; +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.ClientMessageReader; +import com.hazelcast.client.impl.protocol.codec.*; +import com.hazelcast.test.HazelcastParallelClassRunner; +import com.hazelcast.test.annotation.ParallelJVMTest; +import com.hazelcast.test.annotation.QuickTest; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static com.hazelcast.client.impl.protocol.ClientMessage.IS_FINAL_FLAG; +import static com.hazelcast.client.protocol.compatibility.ReferenceObjects.*; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; + +@RunWith(HazelcastParallelClassRunner.class) +@Category({QuickTest.class, ParallelJVMTest.class}) +public class MemberCompatibilityNullTest_2_7 { + private final List clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.7.protocol.compatibility.null.binary").getFile()); + InputStream inputStream = new FileInputStream(file); + byte[] data = new byte[(int) file.length()]; + inputStream.read(data); + ByteBuffer buffer = ByteBuffer.wrap(data); + ClientMessageReader reader = new ClientMessageReader(0); + while (reader.readFrom(buffer, true)) { + clientMessages.add(reader.getClientMessage()); + reader.reset(); + } + } + + @Test + public void test_ClientAuthenticationCodec_decodeRequest() { + int fileClientMessageIndex = 0; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCodec.RequestParameters parameters = ClientAuthenticationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(null, parameters.username)); + assertTrue(isEqual(null, parameters.password)); + assertTrue(isEqual(null, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ClientAuthenticationCodec_encodeResponse() { + int fileClientMessageIndex = 1; + ClientMessage encoded = ClientAuthenticationCodec.encodeResponse(aByte, null, null, aByte, aString, anInt, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAuthenticationCustomCodec_decodeRequest() { + int fileClientMessageIndex = 2; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCustomCodec.RequestParameters parameters = ClientAuthenticationCustomCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(aByteArray, parameters.credentials)); + assertTrue(isEqual(null, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ClientAuthenticationCustomCodec_encodeResponse() { + int fileClientMessageIndex = 3; + ClientMessage encoded = ClientAuthenticationCustomCodec.encodeResponse(aByte, null, null, aByte, aString, anInt, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_decodeRequest() { + int fileClientMessageIndex = 4; + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodeResponse() { + int fileClientMessageIndex = 5; + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodeMembersViewEvent() { + int fileClientMessageIndex = 6; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodeMembersViewEvent(anInt, aListOfMemberInfos); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodePartitionsViewEvent() { + int fileClientMessageIndex = 7; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodePartitionsViewEvent(anInt, aListOfUUIDToListOfIntegers); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxyCodec_decodeRequest() { + int fileClientMessageIndex = 8; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientCreateProxyCodec.RequestParameters parameters = ClientCreateProxyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.serviceName)); + } + + @Test + public void test_ClientCreateProxyCodec_encodeResponse() { + int fileClientMessageIndex = 9; + ClientMessage encoded = ClientCreateProxyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDestroyProxyCodec_decodeRequest() { + int fileClientMessageIndex = 10; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientDestroyProxyCodec.RequestParameters parameters = ClientDestroyProxyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.serviceName)); + } + + @Test + public void test_ClientDestroyProxyCodec_encodeResponse() { + int fileClientMessageIndex = 11; + ClientMessage encoded = ClientDestroyProxyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 12; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientAddPartitionLostListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 13; + ClientMessage encoded = ClientAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_encodePartitionLostEvent() { + int fileClientMessageIndex = 14; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddPartitionLostListenerCodec.encodePartitionLostEvent(anInt, anInt, null); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 15; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientRemovePartitionLostListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 16; + ClientMessage encoded = ClientRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientGetDistributedObjectsCodec_decodeRequest() { + int fileClientMessageIndex = 17; + } + + @Test + public void test_ClientGetDistributedObjectsCodec_encodeResponse() { + int fileClientMessageIndex = 18; + ClientMessage encoded = ClientGetDistributedObjectsCodec.encodeResponse(aListOfDistributedObjectInfo); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_decodeRequest() { + int fileClientMessageIndex = 19; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientAddDistributedObjectListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_encodeResponse() { + int fileClientMessageIndex = 20; + ClientMessage encoded = ClientAddDistributedObjectListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_encodeDistributedObjectEvent() { + int fileClientMessageIndex = 21; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddDistributedObjectListenerCodec.encodeDistributedObjectEvent(aString, aString, aString, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_decodeRequest() { + int fileClientMessageIndex = 22; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientRemoveDistributedObjectListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_encodeResponse() { + int fileClientMessageIndex = 23; + ClientMessage encoded = ClientRemoveDistributedObjectListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientPingCodec_decodeRequest() { + int fileClientMessageIndex = 24; + } + + @Test + public void test_ClientPingCodec_encodeResponse() { + int fileClientMessageIndex = 25; + ClientMessage encoded = ClientPingCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientStatisticsCodec_decodeRequest() { + int fileClientMessageIndex = 26; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientStatisticsCodec.RequestParameters parameters = ClientStatisticsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.timestamp)); + assertTrue(isEqual(aString, parameters.clientAttributes)); + assertTrue(isEqual(aByteArray, parameters.metricsBlob)); + } + + @Test + public void test_ClientStatisticsCodec_encodeResponse() { + int fileClientMessageIndex = 27; + ClientMessage encoded = ClientStatisticsCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDeployClassesCodec_decodeRequest() { + int fileClientMessageIndex = 28; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToByteArray, ClientDeployClassesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientDeployClassesCodec_encodeResponse() { + int fileClientMessageIndex = 29; + ClientMessage encoded = ClientDeployClassesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxiesCodec_decodeRequest() { + int fileClientMessageIndex = 30; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToString, ClientCreateProxiesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientCreateProxiesCodec_encodeResponse() { + int fileClientMessageIndex = 31; + ClientMessage encoded = ClientCreateProxiesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientLocalBackupListenerCodec_decodeRequest() { + int fileClientMessageIndex = 32; + } + + @Test + public void test_ClientLocalBackupListenerCodec_encodeResponse() { + int fileClientMessageIndex = 33; + ClientMessage encoded = ClientLocalBackupListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientLocalBackupListenerCodec_encodeBackupEvent() { + int fileClientMessageIndex = 34; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientLocalBackupListenerCodec.encodeBackupEvent(aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_decodeRequest() { + int fileClientMessageIndex = 35; + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_encodeResponse() { + int fileClientMessageIndex = 36; + ClientMessage encoded = ClientTriggerPartitionAssignmentCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 37; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientAddMigrationListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 38; + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeMigrationEvent() { + int fileClientMessageIndex = 39; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeMigrationEvent(aMigrationState, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeReplicaMigrationEvent() { + int fileClientMessageIndex = 40; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeReplicaMigrationEvent(aMigrationState, anInt, anInt, null, null, aBoolean, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 41; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientRemoveMigrationListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 42; + ClientMessage encoded = ClientRemoveMigrationListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendSchemaCodec_decodeRequest() { + int fileClientMessageIndex = 43; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aSchema, ClientSendSchemaCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientSendSchemaCodec_encodeResponse() { + int fileClientMessageIndex = 44; + ClientMessage encoded = ClientSendSchemaCodec.encodeResponse(aSetOfUUIDs); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientFetchSchemaCodec_decodeRequest() { + int fileClientMessageIndex = 45; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ClientFetchSchemaCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientFetchSchemaCodec_encodeResponse() { + int fileClientMessageIndex = 46; + ClientMessage encoded = ClientFetchSchemaCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendAllSchemasCodec_decodeRequest() { + int fileClientMessageIndex = 47; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfSchemas, ClientSendAllSchemasCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientSendAllSchemasCodec_encodeResponse() { + int fileClientMessageIndex = 48; + ClientMessage encoded = ClientSendAllSchemasCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutCodec_decodeRequest() { + int fileClientMessageIndex = 49; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutCodec.RequestParameters parameters = MapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapPutCodec_encodeResponse() { + int fileClientMessageIndex = 50; + ClientMessage encoded = MapPutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeRequest() { + int fileClientMessageIndex = 51; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetCodec.RequestParameters parameters = MapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapGetCodec_encodeResponse() { + int fileClientMessageIndex = 52; + ClientMessage encoded = MapGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 53; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveCodec.RequestParameters parameters = MapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 54; + ClientMessage encoded = MapRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 55; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapReplaceCodec.RequestParameters parameters = MapReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 56; + ClientMessage encoded = MapReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 57; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapReplaceIfSameCodec.RequestParameters parameters = MapReplaceIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.testValue)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapReplaceIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 58; + ClientMessage encoded = MapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 59; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapContainsKeyCodec.RequestParameters parameters = MapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 60; + ClientMessage encoded = MapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapContainsValueCodec.RequestParameters parameters = MapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_MapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 62; + ClientMessage encoded = MapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 63; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveIfSameCodec.RequestParameters parameters = MapRemoveIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapRemoveIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 64; + ClientMessage encoded = MapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 65; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapDeleteCodec.RequestParameters parameters = MapDeleteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapDeleteCodec_encodeResponse() { + int fileClientMessageIndex = 66; + ClientMessage encoded = MapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeRequest() { + int fileClientMessageIndex = 67; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapFlushCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapFlushCodec_encodeResponse() { + int fileClientMessageIndex = 68; + ClientMessage encoded = MapFlushCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 69; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapTryRemoveCodec.RequestParameters parameters = MapTryRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_MapTryRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 70; + ClientMessage encoded = MapTryRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryPutCodec_decodeRequest() { + int fileClientMessageIndex = 71; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapTryPutCodec.RequestParameters parameters = MapTryPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_MapTryPutCodec_encodeResponse() { + int fileClientMessageIndex = 72; + ClientMessage encoded = MapTryPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientCodec_decodeRequest() { + int fileClientMessageIndex = 73; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutTransientCodec.RequestParameters parameters = MapPutTransientCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapPutTransientCodec_encodeResponse() { + int fileClientMessageIndex = 74; + ClientMessage encoded = MapPutTransientCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 75; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutIfAbsentCodec.RequestParameters parameters = MapPutIfAbsentCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapPutIfAbsentCodec_encodeResponse() { + int fileClientMessageIndex = 76; + ClientMessage encoded = MapPutIfAbsentCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetCodec_decodeRequest() { + int fileClientMessageIndex = 77; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSetCodec.RequestParameters parameters = MapSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapSetCodec_encodeResponse() { + int fileClientMessageIndex = 78; + ClientMessage encoded = MapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLockCodec_decodeRequest() { + int fileClientMessageIndex = 79; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapLockCodec.RequestParameters parameters = MapLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapLockCodec_encodeResponse() { + int fileClientMessageIndex = 80; + ClientMessage encoded = MapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 81; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapTryLockCodec.RequestParameters parameters = MapTryLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.lease)); + assertTrue(isEqual(aLong, parameters.timeout)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapTryLockCodec_encodeResponse() { + int fileClientMessageIndex = 82; + ClientMessage encoded = MapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 83; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapIsLockedCodec.RequestParameters parameters = MapIsLockedCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_MapIsLockedCodec_encodeResponse() { + int fileClientMessageIndex = 84; + ClientMessage encoded = MapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 85; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapUnlockCodec.RequestParameters parameters = MapUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 86; + ClientMessage encoded = MapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 87; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddInterceptorCodec.RequestParameters parameters = MapAddInterceptorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.interceptor)); + } + + @Test + public void test_MapAddInterceptorCodec_encodeResponse() { + int fileClientMessageIndex = 88; + ClientMessage encoded = MapAddInterceptorCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 89; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveInterceptorCodec.RequestParameters parameters = MapRemoveInterceptorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.id)); + } + + @Test + public void test_MapRemoveInterceptorCodec_encodeResponse() { + int fileClientMessageIndex = 90; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 91; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 92; + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 93; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 94; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 95; + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 96; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 97; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyCodec.RequestParameters parameters = MapAddEntryListenerToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 98; + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 99; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 100; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerCodec.RequestParameters parameters = MapAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 101; + ClientMessage encoded = MapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 102; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 103; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveEntryListenerCodec.RequestParameters parameters = MapRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_MapRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 104; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 105; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddPartitionLostListenerCodec.RequestParameters parameters = MapAddPartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 106; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() { + int fileClientMessageIndex = 107; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeMapPartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemovePartitionLostListenerCodec.RequestParameters parameters = MapRemovePartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 109; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeRequest() { + int fileClientMessageIndex = 110; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetEntryViewCodec.RequestParameters parameters = MapGetEntryViewCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapGetEntryViewCodec_encodeResponse() { + int fileClientMessageIndex = 111; + ClientMessage encoded = MapGetEntryViewCodec.encodeResponse(null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeRequest() { + int fileClientMessageIndex = 112; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEvictCodec.RequestParameters parameters = MapEvictCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapEvictCodec_encodeResponse() { + int fileClientMessageIndex = 113; + ClientMessage encoded = MapEvictCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEvictAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeResponse() { + int fileClientMessageIndex = 115; + ClientMessage encoded = MapEvictAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 116; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapLoadAllCodec.RequestParameters parameters = MapLoadAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.replaceExistingValues)); + } + + @Test + public void test_MapLoadAllCodec_encodeResponse() { + int fileClientMessageIndex = 117; + ClientMessage encoded = MapLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapLoadGivenKeysCodec.RequestParameters parameters = MapLoadGivenKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(aBoolean, parameters.replaceExistingValues)); + } + + @Test + public void test_MapLoadGivenKeysCodec_encodeResponse() { + int fileClientMessageIndex = 119; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage encoded = MapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 122; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetAllCodec.RequestParameters parameters = MapGetAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_MapGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 123; + ClientMessage encoded = MapGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 124; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 125; + ClientMessage encoded = MapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 126; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 127; + ClientMessage encoded = MapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 128; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapKeySetWithPredicateCodec.RequestParameters parameters = MapKeySetWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapKeySetWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 129; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapValuesWithPredicateCodec.RequestParameters parameters = MapValuesWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapValuesWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEntriesWithPredicateCodec.RequestParameters parameters = MapEntriesWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapEntriesWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeRequest() { + int fileClientMessageIndex = 134; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddIndexCodec.RequestParameters parameters = MapAddIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anIndexConfig, parameters.indexConfig)); + } + + @Test + public void test_MapAddIndexCodec_encodeResponse() { + int fileClientMessageIndex = 135; + ClientMessage encoded = MapAddIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 137; + ClientMessage encoded = MapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 138; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 139; + ClientMessage encoded = MapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 140; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutAllCodec.RequestParameters parameters = MapPutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + assertTrue(parameters.isTriggerMapLoaderExists); + assertTrue(isEqual(aBoolean, parameters.triggerMapLoader)); + } + + @Test + public void test_MapPutAllCodec_encodeResponse() { + int fileClientMessageIndex = 141; + ClientMessage encoded = MapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeRequest() { + int fileClientMessageIndex = 142; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapClearCodec_encodeResponse() { + int fileClientMessageIndex = 143; + ClientMessage encoded = MapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeRequest() { + int fileClientMessageIndex = 144; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteOnKeyCodec.RequestParameters parameters = MapExecuteOnKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapExecuteOnKeyCodec_encodeResponse() { + int fileClientMessageIndex = 145; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 146; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSubmitToKeyCodec.RequestParameters parameters = MapSubmitToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapSubmitToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 147; + ClientMessage encoded = MapSubmitToKeyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 148; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteOnAllKeysCodec.RequestParameters parameters = MapExecuteOnAllKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_encodeResponse() { + int fileClientMessageIndex = 149; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 150; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteWithPredicateCodec.RequestParameters parameters = MapExecuteWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapExecuteWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 151; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeRequest() { + int fileClientMessageIndex = 152; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteOnKeysCodec.RequestParameters parameters = MapExecuteOnKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_MapExecuteOnKeysCodec_encodeResponse() { + int fileClientMessageIndex = 153; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 154; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapForceUnlockCodec.RequestParameters parameters = MapForceUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapForceUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 155; + ClientMessage encoded = MapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 156; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapKeySetWithPagingPredicateCodec.RequestParameters parameters = MapKeySetWithPagingPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aPagingPredicateHolder, parameters.predicate)); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 157; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 158; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapValuesWithPagingPredicateCodec.RequestParameters parameters = MapValuesWithPagingPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aPagingPredicateHolder, parameters.predicate)); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 159; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 160; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEntriesWithPagingPredicateCodec.RequestParameters parameters = MapEntriesWithPagingPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aPagingPredicateHolder, parameters.predicate)); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 161; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeResponse(aListOfDataToData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeRequest() { + int fileClientMessageIndex = 162; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchKeysCodec.RequestParameters parameters = MapFetchKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_MapFetchKeysCodec_encodeResponse() { + int fileClientMessageIndex = 163; + ClientMessage encoded = MapFetchKeysCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 164; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchEntriesCodec.RequestParameters parameters = MapFetchEntriesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_MapFetchEntriesCodec_encodeResponse() { + int fileClientMessageIndex = 165; + ClientMessage encoded = MapFetchEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeRequest() { + int fileClientMessageIndex = 166; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAggregateCodec.RequestParameters parameters = MapAggregateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.aggregator)); + } + + @Test + public void test_MapAggregateCodec_encodeResponse() { + int fileClientMessageIndex = 167; + ClientMessage encoded = MapAggregateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 168; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAggregateWithPredicateCodec.RequestParameters parameters = MapAggregateWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.aggregator)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapAggregateWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 169; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeRequest() { + int fileClientMessageIndex = 170; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapProjectCodec.RequestParameters parameters = MapProjectCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.projection)); + } + + @Test + public void test_MapProjectCodec_encodeResponse() { + int fileClientMessageIndex = 171; + ClientMessage encoded = MapProjectCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 172; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapProjectWithPredicateCodec.RequestParameters parameters = MapProjectWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.projection)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapProjectWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 173; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 174; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aListOfStrings, parameters.names)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 175; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 176; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveAllCodec.RequestParameters parameters = MapRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 177; + ClientMessage encoded = MapRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 178; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodec.RequestParameters parameters = MapAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 179; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidationEvent() { + int fileClientMessageIndex = 180; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapInvalidationEvent(null, aUUID, aUUID, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 181; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapBatchInvalidationEvent(aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchWithQueryCodec_decodeRequest() { + int fileClientMessageIndex = 182; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchWithQueryCodec.RequestParameters parameters = MapFetchWithQueryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + assertTrue(isEqual(aData, parameters.projection)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapFetchWithQueryCodec_encodeResponse() { + int fileClientMessageIndex = 183; + ClientMessage encoded = MapFetchWithQueryCodec.encodeResponse(aListOfData, aListOfIntegerToInteger); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 184; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 185; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 186; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEventJournalReadCodec.RequestParameters parameters = MapEventJournalReadCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.startSequence)); + assertTrue(isEqual(anInt, parameters.minSize)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(null, parameters.predicate)); + assertTrue(isEqual(null, parameters.projection)); + } + + @Test + public void test_MapEventJournalReadCodec_encodeResponse() { + int fileClientMessageIndex = 187; + ClientMessage encoded = MapEventJournalReadCodec.encodeResponse(anInt, aListOfData, null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeRequest() { + int fileClientMessageIndex = 188; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSetTtlCodec.RequestParameters parameters = MapSetTtlCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapSetTtlCodec_encodeResponse() { + int fileClientMessageIndex = 189; + ClientMessage encoded = MapSetTtlCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 190; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutWithMaxIdleCodec.RequestParameters parameters = MapPutWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapPutWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 191; + ClientMessage encoded = MapPutWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 192; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutTransientWithMaxIdleCodec.RequestParameters parameters = MapPutTransientWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 193; + ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 194; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutIfAbsentWithMaxIdleCodec.RequestParameters parameters = MapPutIfAbsentWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 195; + ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 196; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSetWithMaxIdleCodec.RequestParameters parameters = MapSetWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapSetWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 197; + ClientMessage encoded = MapSetWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceAllCodec_decodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapReplaceAllCodec.RequestParameters parameters = MapReplaceAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + } + + @Test + public void test_MapReplaceAllCodec_encodeResponse() { + int fileClientMessageIndex = 199; + ClientMessage encoded = MapReplaceAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllWithMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutAllWithMetadataCodec.RequestParameters parameters = MapPutAllWithMetadataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfSimpleEntryViews, parameters.entries)); + } + + @Test + public void test_MapPutAllWithMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 201; + ClientMessage encoded = MapPutAllWithMetadataCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapPutCodec.RequestParameters parameters = MultiMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage encoded = MultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 204; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapGetCodec.RequestParameters parameters = MultiMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 205; + ClientMessage encoded = MultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 206; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapRemoveCodec.RequestParameters parameters = MultiMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 207; + ClientMessage encoded = MultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 208; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 209; + ClientMessage encoded = MultiMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage encoded = MultiMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 213; + ClientMessage encoded = MultiMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 214; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapContainsKeyCodec.RequestParameters parameters = MultiMapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 215; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 216; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapContainsValueCodec.RequestParameters parameters = MultiMapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_MultiMapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 217; + ClientMessage encoded = MultiMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeRequest() { + int fileClientMessageIndex = 218; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapContainsEntryCodec.RequestParameters parameters = MultiMapContainsEntryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapContainsEntryCodec_encodeResponse() { + int fileClientMessageIndex = 219; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 220; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 221; + ClientMessage encoded = MultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 222; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 223; + ClientMessage encoded = MultiMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 224; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapValueCountCodec.RequestParameters parameters = MultiMapValueCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapValueCountCodec_encodeResponse() { + int fileClientMessageIndex = 225; + ClientMessage encoded = MultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 226; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerToKeyCodec.RequestParameters parameters = MultiMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 227; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 228; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 229; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerCodec.RequestParameters parameters = MultiMapAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 230; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 231; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 232; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapRemoveEntryListenerCodec.RequestParameters parameters = MultiMapRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 233; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapLockCodec_decodeRequest() { + int fileClientMessageIndex = 234; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapLockCodec.RequestParameters parameters = MultiMapLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapLockCodec_encodeResponse() { + int fileClientMessageIndex = 235; + ClientMessage encoded = MultiMapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 236; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapTryLockCodec.RequestParameters parameters = MultiMapTryLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.lease)); + assertTrue(isEqual(aLong, parameters.timeout)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapTryLockCodec_encodeResponse() { + int fileClientMessageIndex = 237; + ClientMessage encoded = MultiMapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 238; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapIsLockedCodec.RequestParameters parameters = MultiMapIsLockedCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_MultiMapIsLockedCodec_encodeResponse() { + int fileClientMessageIndex = 239; + ClientMessage encoded = MultiMapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 240; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapUnlockCodec.RequestParameters parameters = MultiMapUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 241; + ClientMessage encoded = MultiMapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 242; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapForceUnlockCodec.RequestParameters parameters = MultiMapForceUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapForceUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 243; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapRemoveEntryCodec.RequestParameters parameters = MultiMapRemoveEntryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapRemoveEntryCodec_encodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 246; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapDeleteCodec.RequestParameters parameters = MultiMapDeleteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapDeleteCodec_encodeResponse() { + int fileClientMessageIndex = 247; + ClientMessage encoded = MultiMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 248; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapPutAllCodec.RequestParameters parameters = MultiMapPutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToListOfData, parameters.entries)); + } + + @Test + public void test_MultiMapPutAllCodec_encodeResponse() { + int fileClientMessageIndex = 249; + ClientMessage encoded = MultiMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueOfferCodec.RequestParameters parameters = QueueOfferCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + } + + @Test + public void test_QueueOfferCodec_encodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage encoded = QueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueuePutCodec.RequestParameters parameters = QueuePutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_QueuePutCodec_encodeResponse() { + int fileClientMessageIndex = 253; + ClientMessage encoded = QueuePutCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueSizeCodec_encodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage encoded = QueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueRemoveCodec.RequestParameters parameters = QueueRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_QueueRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage encoded = QueueRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 258; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueuePollCodec.RequestParameters parameters = QueuePollCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + } + + @Test + public void test_QueuePollCodec_encodeResponse() { + int fileClientMessageIndex = 259; + ClientMessage encoded = QueuePollCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 260; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueTakeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeResponse() { + int fileClientMessageIndex = 261; + ClientMessage encoded = QueueTakeCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 262; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueuePeekCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeResponse() { + int fileClientMessageIndex = 263; + ClientMessage encoded = QueuePeekCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 264; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 265; + ClientMessage encoded = QueueIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeRequest() { + int fileClientMessageIndex = 266; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueDrainToCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeResponse() { + int fileClientMessageIndex = 267; + ClientMessage encoded = QueueDrainToCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueDrainToMaxSizeCodec.RequestParameters parameters = QueueDrainToMaxSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.maxSize)); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_encodeResponse() { + int fileClientMessageIndex = 269; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeRequest() { + int fileClientMessageIndex = 270; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueContainsCodec.RequestParameters parameters = QueueContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_QueueContainsCodec_encodeResponse() { + int fileClientMessageIndex = 271; + ClientMessage encoded = QueueContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 272; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueContainsAllCodec.RequestParameters parameters = QueueContainsAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueContainsAllCodec_encodeResponse() { + int fileClientMessageIndex = 273; + ClientMessage encoded = QueueContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 274; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueCompareAndRemoveAllCodec.RequestParameters parameters = QueueCompareAndRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 275; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 276; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueCompareAndRetainAllCodec.RequestParameters parameters = QueueCompareAndRetainAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_encodeResponse() { + int fileClientMessageIndex = 277; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeRequest() { + int fileClientMessageIndex = 278; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeResponse() { + int fileClientMessageIndex = 279; + ClientMessage encoded = QueueClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 280; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddAllCodec.RequestParameters parameters = QueueAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 281; + ClientMessage encoded = QueueAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 282; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddListenerCodec.RequestParameters parameters = QueueAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_QueueAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 283; + ClientMessage encoded = QueueAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 284; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = QueueAddListenerCodec.encodeItemEvent(null, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 285; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueRemoveListenerCodec.RequestParameters parameters = QueueRemoveListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_QueueRemoveListenerCodec_encodeResponse() { + int fileClientMessageIndex = 286; + ClientMessage encoded = QueueRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 287; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 288; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 289; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 290; + ClientMessage encoded = QueueIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeRequest() { + int fileClientMessageIndex = 291; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicPublishCodec.RequestParameters parameters = TopicPublishCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.message)); + } + + @Test + public void test_TopicPublishCodec_encodeResponse() { + int fileClientMessageIndex = 292; + ClientMessage encoded = TopicPublishCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 293; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicAddMessageListenerCodec.RequestParameters parameters = TopicAddMessageListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeResponse() { + int fileClientMessageIndex = 294; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { + int fileClientMessageIndex = 295; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = TopicAddMessageListenerCodec.encodeTopicEvent(aData, aLong, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 296; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicRemoveMessageListenerCodec.RequestParameters parameters = TopicRemoveMessageListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_encodeResponse() { + int fileClientMessageIndex = 297; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeRequest() { + int fileClientMessageIndex = 298; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicPublishAllCodec.RequestParameters parameters = TopicPublishAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.messages)); + } + + @Test + public void test_TopicPublishAllCodec_encodeResponse() { + int fileClientMessageIndex = 299; + ClientMessage encoded = TopicPublishAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 300; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListSizeCodec_encodeResponse() { + int fileClientMessageIndex = 301; + ClientMessage encoded = ListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeRequest() { + int fileClientMessageIndex = 302; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListContainsCodec.RequestParameters parameters = ListContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListContainsCodec_encodeResponse() { + int fileClientMessageIndex = 303; + ClientMessage encoded = ListContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 304; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListContainsAllCodec.RequestParameters parameters = ListContainsAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_ListContainsAllCodec_encodeResponse() { + int fileClientMessageIndex = 305; + ClientMessage encoded = ListContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddCodec.RequestParameters parameters = ListAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListAddCodec_encodeResponse() { + int fileClientMessageIndex = 307; + ClientMessage encoded = ListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListRemoveCodec.RequestParameters parameters = ListRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage encoded = ListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 310; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddAllCodec.RequestParameters parameters = ListAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + } + + @Test + public void test_ListAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 311; + ClientMessage encoded = ListAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 312; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListCompareAndRemoveAllCodec.RequestParameters parameters = ListCompareAndRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 313; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 314; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListCompareAndRetainAllCodec.RequestParameters parameters = ListCompareAndRetainAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_ListCompareAndRetainAllCodec_encodeResponse() { + int fileClientMessageIndex = 315; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeRequest() { + int fileClientMessageIndex = 316; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeResponse() { + int fileClientMessageIndex = 317; + ClientMessage encoded = ListClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 318; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 319; + ClientMessage encoded = ListGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 320; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddListenerCodec.RequestParameters parameters = ListAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ListAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 321; + ClientMessage encoded = ListAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 322; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ListAddListenerCodec.encodeItemEvent(null, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 323; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListRemoveListenerCodec.RequestParameters parameters = ListRemoveListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_ListRemoveListenerCodec_encodeResponse() { + int fileClientMessageIndex = 324; + ClientMessage encoded = ListRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 325; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 326; + ClientMessage encoded = ListIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 327; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddAllWithIndexCodec.RequestParameters parameters = ListAddAllWithIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + } + + @Test + public void test_ListAddAllWithIndexCodec_encodeResponse() { + int fileClientMessageIndex = 328; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeRequest() { + int fileClientMessageIndex = 329; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListGetCodec.RequestParameters parameters = ListGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + } + + @Test + public void test_ListGetCodec_encodeResponse() { + int fileClientMessageIndex = 330; + ClientMessage encoded = ListGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeRequest() { + int fileClientMessageIndex = 331; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListSetCodec.RequestParameters parameters = ListSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListSetCodec_encodeResponse() { + int fileClientMessageIndex = 332; + ClientMessage encoded = ListSetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddWithIndexCodec.RequestParameters parameters = ListAddWithIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListAddWithIndexCodec_encodeResponse() { + int fileClientMessageIndex = 334; + ClientMessage encoded = ListAddWithIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 335; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListRemoveWithIndexCodec.RequestParameters parameters = ListRemoveWithIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + } + + @Test + public void test_ListRemoveWithIndexCodec_encodeResponse() { + int fileClientMessageIndex = 336; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListLastIndexOfCodec.RequestParameters parameters = ListLastIndexOfCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListLastIndexOfCodec_encodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage encoded = ListLastIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 339; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListIndexOfCodec.RequestParameters parameters = ListIndexOfCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListIndexOfCodec_encodeResponse() { + int fileClientMessageIndex = 340; + ClientMessage encoded = ListIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeRequest() { + int fileClientMessageIndex = 341; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListSubCodec.RequestParameters parameters = ListSubCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.from)); + assertTrue(isEqual(anInt, parameters.to)); + } + + @Test + public void test_ListSubCodec_encodeResponse() { + int fileClientMessageIndex = 342; + ClientMessage encoded = ListSubCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 343; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 344; + ClientMessage encoded = ListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 345; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListListIteratorCodec.RequestParameters parameters = ListListIteratorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + } + + @Test + public void test_ListListIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 346; + ClientMessage encoded = ListListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 347; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeResponse() { + int fileClientMessageIndex = 348; + ClientMessage encoded = SetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeRequest() { + int fileClientMessageIndex = 349; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetContainsCodec.RequestParameters parameters = SetContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_SetContainsCodec_encodeResponse() { + int fileClientMessageIndex = 350; + ClientMessage encoded = SetContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 351; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetContainsAllCodec.RequestParameters parameters = SetContainsAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.items)); + } + + @Test + public void test_SetContainsAllCodec_encodeResponse() { + int fileClientMessageIndex = 352; + ClientMessage encoded = SetContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddCodec.RequestParameters parameters = SetAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_SetAddCodec_encodeResponse() { + int fileClientMessageIndex = 354; + ClientMessage encoded = SetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetRemoveCodec.RequestParameters parameters = SetRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_SetRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage encoded = SetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 357; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddAllCodec.RequestParameters parameters = SetAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + } + + @Test + public void test_SetAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 358; + ClientMessage encoded = SetAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 359; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetCompareAndRemoveAllCodec.RequestParameters parameters = SetCompareAndRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 360; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 361; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetCompareAndRetainAllCodec.RequestParameters parameters = SetCompareAndRetainAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_SetCompareAndRetainAllCodec_encodeResponse() { + int fileClientMessageIndex = 362; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeRequest() { + int fileClientMessageIndex = 363; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeResponse() { + int fileClientMessageIndex = 364; + ClientMessage encoded = SetClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 365; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 366; + ClientMessage encoded = SetGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 367; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddListenerCodec.RequestParameters parameters = SetAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_SetAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 368; + ClientMessage encoded = SetAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 369; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = SetAddListenerCodec.encodeItemEvent(null, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 370; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetRemoveListenerCodec.RequestParameters parameters = SetRemoveListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_SetRemoveListenerCodec_encodeResponse() { + int fileClientMessageIndex = 371; + ClientMessage encoded = SetRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 372; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 373; + ClientMessage encoded = SetIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockLockCodec_decodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockLockCodec.RequestParameters parameters = FencedLockLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + } + + @Test + public void test_FencedLockLockCodec_encodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage encoded = FencedLockLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 376; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockTryLockCodec.RequestParameters parameters = FencedLockTryLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(aLong, parameters.timeoutMs)); + } + + @Test + public void test_FencedLockTryLockCodec_encodeResponse() { + int fileClientMessageIndex = 377; + ClientMessage encoded = FencedLockTryLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 378; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockUnlockCodec.RequestParameters parameters = FencedLockUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + } + + @Test + public void test_FencedLockUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 379; + ClientMessage encoded = FencedLockUnlockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { + int fileClientMessageIndex = 380; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockGetLockOwnershipCodec.RequestParameters parameters = FencedLockGetLockOwnershipCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_encodeResponse() { + int fileClientMessageIndex = 381; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeResponse(aLong, anInt, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 382; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 383; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 384; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 385; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 386; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceCancelOnPartitionCodec.RequestParameters parameters = ExecutorServiceCancelOnPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aBoolean, parameters.interrupt)); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 387; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { + int fileClientMessageIndex = 388; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceCancelOnMemberCodec.RequestParameters parameters = ExecutorServiceCancelOnMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aUUID, parameters.memberUUID)); + assertTrue(isEqual(aBoolean, parameters.interrupt)); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_encodeResponse() { + int fileClientMessageIndex = 389; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 390; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceSubmitToPartitionCodec.RequestParameters parameters = ExecutorServiceSubmitToPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aData, parameters.callable)); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 391; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 392; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceSubmitToMemberCodec.RequestParameters parameters = ExecutorServiceSubmitToMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aData, parameters.callable)); + assertTrue(isEqual(aUUID, parameters.memberUUID)); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_encodeResponse() { + int fileClientMessageIndex = 393; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeRequest() { + int fileClientMessageIndex = 394; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongApplyCodec.RequestParameters parameters = AtomicLongApplyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + } + + @Test + public void test_AtomicLongApplyCodec_encodeResponse() { + int fileClientMessageIndex = 395; + ClientMessage encoded = AtomicLongApplyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeRequest() { + int fileClientMessageIndex = 396; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongAlterCodec.RequestParameters parameters = AtomicLongAlterCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + assertTrue(isEqual(anInt, parameters.returnValueType)); + } + + @Test + public void test_AtomicLongAlterCodec_encodeResponse() { + int fileClientMessageIndex = 397; + ClientMessage encoded = AtomicLongAlterCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeRequest() { + int fileClientMessageIndex = 398; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongAddAndGetCodec.RequestParameters parameters = AtomicLongAddAndGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.delta)); + } + + @Test + public void test_AtomicLongAddAndGetCodec_encodeResponse() { + int fileClientMessageIndex = 399; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 400; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongCompareAndSetCodec.RequestParameters parameters = AtomicLongCompareAndSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.expected)); + assertTrue(isEqual(aLong, parameters.updated)); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_encodeResponse() { + int fileClientMessageIndex = 401; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeRequest() { + int fileClientMessageIndex = 402; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongGetCodec.RequestParameters parameters = AtomicLongGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_AtomicLongGetCodec_encodeResponse() { + int fileClientMessageIndex = 403; + ClientMessage encoded = AtomicLongGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeRequest() { + int fileClientMessageIndex = 404; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongGetAndAddCodec.RequestParameters parameters = AtomicLongGetAndAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.delta)); + } + + @Test + public void test_AtomicLongGetAndAddCodec_encodeResponse() { + int fileClientMessageIndex = 405; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 406; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongGetAndSetCodec.RequestParameters parameters = AtomicLongGetAndSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.newValue)); + } + + @Test + public void test_AtomicLongGetAndSetCodec_encodeResponse() { + int fileClientMessageIndex = 407; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefApplyCodec_decodeRequest() { + int fileClientMessageIndex = 408; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefApplyCodec.RequestParameters parameters = AtomicRefApplyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + assertTrue(isEqual(anInt, parameters.returnValueType)); + assertTrue(isEqual(aBoolean, parameters.alter)); + } + + @Test + public void test_AtomicRefApplyCodec_encodeResponse() { + int fileClientMessageIndex = 409; + ClientMessage encoded = AtomicRefApplyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 410; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefCompareAndSetCodec.RequestParameters parameters = AtomicRefCompareAndSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.oldValue)); + assertTrue(isEqual(null, parameters.newValue)); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_encodeResponse() { + int fileClientMessageIndex = 411; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeRequest() { + int fileClientMessageIndex = 412; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefContainsCodec.RequestParameters parameters = AtomicRefContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.value)); + } + + @Test + public void test_AtomicRefContainsCodec_encodeResponse() { + int fileClientMessageIndex = 413; + ClientMessage encoded = AtomicRefContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeRequest() { + int fileClientMessageIndex = 414; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefGetCodec.RequestParameters parameters = AtomicRefGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_AtomicRefGetCodec_encodeResponse() { + int fileClientMessageIndex = 415; + ClientMessage encoded = AtomicRefGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeRequest() { + int fileClientMessageIndex = 416; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefSetCodec.RequestParameters parameters = AtomicRefSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.newValue)); + assertTrue(isEqual(aBoolean, parameters.returnOldValue)); + } + + @Test + public void test_AtomicRefSetCodec_encodeResponse() { + int fileClientMessageIndex = 417; + ClientMessage encoded = AtomicRefSetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeRequest() { + int fileClientMessageIndex = 418; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchTrySetCountCodec.RequestParameters parameters = CountDownLatchTrySetCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.count)); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_encodeResponse() { + int fileClientMessageIndex = 419; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeRequest() { + int fileClientMessageIndex = 420; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchAwaitCodec.RequestParameters parameters = CountDownLatchAwaitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(aLong, parameters.timeoutMs)); + } + + @Test + public void test_CountDownLatchAwaitCodec_encodeResponse() { + int fileClientMessageIndex = 421; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeRequest() { + int fileClientMessageIndex = 422; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchCountDownCodec.RequestParameters parameters = CountDownLatchCountDownCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.expectedRound)); + } + + @Test + public void test_CountDownLatchCountDownCodec_encodeResponse() { + int fileClientMessageIndex = 423; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeRequest() { + int fileClientMessageIndex = 424; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchGetCountCodec.RequestParameters parameters = CountDownLatchGetCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_CountDownLatchGetCountCodec_encodeResponse() { + int fileClientMessageIndex = 425; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeRequest() { + int fileClientMessageIndex = 426; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchGetRoundCodec.RequestParameters parameters = CountDownLatchGetRoundCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_CountDownLatchGetRoundCodec_encodeResponse() { + int fileClientMessageIndex = 427; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeRequest() { + int fileClientMessageIndex = 428; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreInitCodec.RequestParameters parameters = SemaphoreInitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.permits)); + } + + @Test + public void test_SemaphoreInitCodec_encodeResponse() { + int fileClientMessageIndex = 429; + ClientMessage encoded = SemaphoreInitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAcquireCodec_decodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreAcquireCodec.RequestParameters parameters = SemaphoreAcquireCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.permits)); + assertTrue(isEqual(aLong, parameters.timeoutMs)); + } + + @Test + public void test_SemaphoreAcquireCodec_encodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage encoded = SemaphoreAcquireCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreReleaseCodec_decodeRequest() { + int fileClientMessageIndex = 432; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreReleaseCodec.RequestParameters parameters = SemaphoreReleaseCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.permits)); + } + + @Test + public void test_SemaphoreReleaseCodec_encodeResponse() { + int fileClientMessageIndex = 433; + ClientMessage encoded = SemaphoreReleaseCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreDrainCodec_decodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreDrainCodec.RequestParameters parameters = SemaphoreDrainCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + } + + @Test + public void test_SemaphoreDrainCodec_encodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage encoded = SemaphoreDrainCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreChangeCodec_decodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreChangeCodec.RequestParameters parameters = SemaphoreChangeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.permits)); + } + + @Test + public void test_SemaphoreChangeCodec_encodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage encoded = SemaphoreChangeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { + int fileClientMessageIndex = 438; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreAvailablePermitsCodec.RequestParameters parameters = SemaphoreAvailablePermitsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_encodeResponse() { + int fileClientMessageIndex = 439; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeRequest() { + int fileClientMessageIndex = 440; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SemaphoreGetSemaphoreTypeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { + int fileClientMessageIndex = 441; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 442; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapPutCodec.RequestParameters parameters = ReplicatedMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_ReplicatedMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 443; + ClientMessage encoded = ReplicatedMapPutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 444; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 445; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 446; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 447; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapContainsKeyCodec.RequestParameters parameters = ReplicatedMapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 449; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 450; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapContainsValueCodec.RequestParameters parameters = ReplicatedMapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 451; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 452; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapGetCodec.RequestParameters parameters = ReplicatedMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_ReplicatedMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 453; + ClientMessage encoded = ReplicatedMapGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 454; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapRemoveCodec.RequestParameters parameters = ReplicatedMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_ReplicatedMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 455; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 456; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapPutAllCodec.RequestParameters parameters = ReplicatedMapPutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + } + + @Test + public void test_ReplicatedMapPutAllCodec_encodeResponse() { + int fileClientMessageIndex = 457; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 458; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 459; + ClientMessage encoded = ReplicatedMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 460; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 461; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 462; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 463; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 464; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 465; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 468; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 469; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 470; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 471; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 472; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapRemoveEntryListenerCodec.RequestParameters parameters = ReplicatedMapRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 473; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 474; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 475; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 476; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 477; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 478; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 479; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 480; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddNearCacheEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddNearCacheEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 481; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 482; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 483; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapContainsKeyCodec.RequestParameters parameters = TransactionalMapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 484; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 485; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapGetCodec.RequestParameters parameters = TransactionalMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 486; + ClientMessage encoded = TransactionalMapGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { + int fileClientMessageIndex = 487; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapGetForUpdateCodec.RequestParameters parameters = TransactionalMapGetForUpdateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_encodeResponse() { + int fileClientMessageIndex = 488; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 489; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapSizeCodec.RequestParameters parameters = TransactionalMapSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 490; + ClientMessage encoded = TransactionalMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 491; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapIsEmptyCodec.RequestParameters parameters = TransactionalMapIsEmptyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 492; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 493; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapPutCodec.RequestParameters parameters = TransactionalMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_TransactionalMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 494; + ClientMessage encoded = TransactionalMapPutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSetCodec_decodeRequest() { + int fileClientMessageIndex = 495; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapSetCodec.RequestParameters parameters = TransactionalMapSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapSetCodec_encodeResponse() { + int fileClientMessageIndex = 496; + ClientMessage encoded = TransactionalMapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 497; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapPutIfAbsentCodec.RequestParameters parameters = TransactionalMapPutIfAbsentCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_encodeResponse() { + int fileClientMessageIndex = 498; + ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 499; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapReplaceCodec.RequestParameters parameters = TransactionalMapReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 500; + ClientMessage encoded = TransactionalMapReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 501; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapReplaceIfSameCodec.RequestParameters parameters = TransactionalMapReplaceIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.oldValue)); + assertTrue(isEqual(aData, parameters.newValue)); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 502; + ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 503; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapRemoveCodec.RequestParameters parameters = TransactionalMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 504; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 505; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapDeleteCodec.RequestParameters parameters = TransactionalMapDeleteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapDeleteCodec_encodeResponse() { + int fileClientMessageIndex = 506; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 507; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapRemoveIfSameCodec.RequestParameters parameters = TransactionalMapRemoveIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 508; + ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 509; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapKeySetCodec.RequestParameters parameters = TransactionalMapKeySetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 510; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 511; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapKeySetWithPredicateCodec.RequestParameters parameters = TransactionalMapKeySetWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 512; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 513; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapValuesCodec.RequestParameters parameters = TransactionalMapValuesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 514; + ClientMessage encoded = TransactionalMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 515; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapValuesWithPredicateCodec.RequestParameters parameters = TransactionalMapValuesWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 516; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 517; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapContainsValueCodec.RequestParameters parameters = TransactionalMapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 518; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 519; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapPutCodec.RequestParameters parameters = TransactionalMultiMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMultiMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 520; + ClientMessage encoded = TransactionalMultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 521; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapGetCodec.RequestParameters parameters = TransactionalMultiMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMultiMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 522; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 523; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapRemoveCodec.RequestParameters parameters = TransactionalMultiMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 524; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 525; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapRemoveEntryCodec.RequestParameters parameters = TransactionalMultiMapRemoveEntryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_encodeResponse() { + int fileClientMessageIndex = 526; + ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 527; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapValueCountCodec.RequestParameters parameters = TransactionalMultiMapValueCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_encodeResponse() { + int fileClientMessageIndex = 528; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 529; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapSizeCodec.RequestParameters parameters = TransactionalMultiMapSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 530; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeRequest() { + int fileClientMessageIndex = 531; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalSetAddCodec.RequestParameters parameters = TransactionalSetAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalSetAddCodec_encodeResponse() { + int fileClientMessageIndex = 532; + ClientMessage encoded = TransactionalSetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 533; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalSetRemoveCodec.RequestParameters parameters = TransactionalSetRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalSetRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 534; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 535; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalSetSizeCodec.RequestParameters parameters = TransactionalSetSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalSetSizeCodec_encodeResponse() { + int fileClientMessageIndex = 536; + ClientMessage encoded = TransactionalSetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeRequest() { + int fileClientMessageIndex = 537; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalListAddCodec.RequestParameters parameters = TransactionalListAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalListAddCodec_encodeResponse() { + int fileClientMessageIndex = 538; + ClientMessage encoded = TransactionalListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 539; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalListRemoveCodec.RequestParameters parameters = TransactionalListRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalListRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 540; + ClientMessage encoded = TransactionalListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 541; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalListSizeCodec.RequestParameters parameters = TransactionalListSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalListSizeCodec_encodeResponse() { + int fileClientMessageIndex = 542; + ClientMessage encoded = TransactionalListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 543; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueueOfferCodec.RequestParameters parameters = TransactionalQueueOfferCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_TransactionalQueueOfferCodec_encodeResponse() { + int fileClientMessageIndex = 544; + ClientMessage encoded = TransactionalQueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 545; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueueTakeCodec.RequestParameters parameters = TransactionalQueueTakeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalQueueTakeCodec_encodeResponse() { + int fileClientMessageIndex = 546; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 547; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueuePollCodec.RequestParameters parameters = TransactionalQueuePollCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_TransactionalQueuePollCodec_encodeResponse() { + int fileClientMessageIndex = 548; + ClientMessage encoded = TransactionalQueuePollCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 549; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueuePeekCodec.RequestParameters parameters = TransactionalQueuePeekCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_TransactionalQueuePeekCodec_encodeResponse() { + int fileClientMessageIndex = 550; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 551; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueueSizeCodec.RequestParameters parameters = TransactionalQueueSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalQueueSizeCodec_encodeResponse() { + int fileClientMessageIndex = 552; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 553; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddEntryListenerCodec.RequestParameters parameters = CacheAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 554; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { + int fileClientMessageIndex = 555; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddEntryListenerCodec.encodeCacheEvent(anInt, aListOfCacheEventData, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheClearCodec_encodeResponse() { + int fileClientMessageIndex = 557; + ClientMessage encoded = CacheClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 558; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveAllKeysCodec.RequestParameters parameters = CacheRemoveAllKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheRemoveAllKeysCodec_encodeResponse() { + int fileClientMessageIndex = 559; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 560; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveAllCodec.RequestParameters parameters = CacheRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 561; + ClientMessage encoded = CacheRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 562; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheContainsKeyCodec.RequestParameters parameters = CacheContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_CacheContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 563; + ClientMessage encoded = CacheContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeRequest() { + int fileClientMessageIndex = 564; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheCreateConfigCodec.RequestParameters parameters = CacheCreateConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aCacheConfigHolder, parameters.cacheConfig)); + assertTrue(isEqual(aBoolean, parameters.createAlsoOnOthers)); + } + + @Test + public void test_CacheCreateConfigCodec_encodeResponse() { + int fileClientMessageIndex = 565; + ClientMessage encoded = CacheCreateConfigCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeRequest() { + int fileClientMessageIndex = 566; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheDestroyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeResponse() { + int fileClientMessageIndex = 567; + ClientMessage encoded = CacheDestroyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEntryProcessorCodec_decodeRequest() { + int fileClientMessageIndex = 568; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEntryProcessorCodec.RequestParameters parameters = CacheEntryProcessorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aListOfData, parameters.arguments)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheEntryProcessorCodec_encodeResponse() { + int fileClientMessageIndex = 569; + ClientMessage encoded = CacheEntryProcessorCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 570; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetAllCodec.RequestParameters parameters = CacheGetAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(null, parameters.expiryPolicy)); + } + + @Test + public void test_CacheGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 571; + ClientMessage encoded = CacheGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 572; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetAndRemoveCodec.RequestParameters parameters = CacheGetAndRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheGetAndRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 573; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 574; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetAndReplaceCodec.RequestParameters parameters = CacheGetAndReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(null, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheGetAndReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 575; + ClientMessage encoded = CacheGetAndReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 576; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetConfigCodec.RequestParameters parameters = CacheGetConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.simpleName)); + } + + @Test + public void test_CacheGetConfigCodec_encodeResponse() { + int fileClientMessageIndex = 577; + ClientMessage encoded = CacheGetConfigCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeRequest() { + int fileClientMessageIndex = 578; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetCodec.RequestParameters parameters = CacheGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(null, parameters.expiryPolicy)); + } + + @Test + public void test_CacheGetCodec_encodeResponse() { + int fileClientMessageIndex = 579; + ClientMessage encoded = CacheGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeRequest() { + int fileClientMessageIndex = 580; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateCodec.RequestParameters parameters = CacheIterateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_CacheIterateCodec_encodeResponse() { + int fileClientMessageIndex = 581; + ClientMessage encoded = CacheIterateCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeRequest() { + int fileClientMessageIndex = 582; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheListenerRegistrationCodec.RequestParameters parameters = CacheListenerRegistrationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.listenerConfig)); + assertTrue(isEqual(aBoolean, parameters.shouldRegister)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_CacheListenerRegistrationCodec_encodeResponse() { + int fileClientMessageIndex = 583; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 584; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheLoadAllCodec.RequestParameters parameters = CacheLoadAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(aBoolean, parameters.replaceExistingValues)); + } + + @Test + public void test_CacheLoadAllCodec_encodeResponse() { + int fileClientMessageIndex = 585; + ClientMessage encoded = CacheLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeRequest() { + int fileClientMessageIndex = 586; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheManagementConfigCodec.RequestParameters parameters = CacheManagementConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.isStat)); + assertTrue(isEqual(aBoolean, parameters.enabled)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_CacheManagementConfigCodec_encodeResponse() { + int fileClientMessageIndex = 587; + ClientMessage encoded = CacheManagementConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 588; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CachePutIfAbsentCodec.RequestParameters parameters = CachePutIfAbsentCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(null, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CachePutIfAbsentCodec_encodeResponse() { + int fileClientMessageIndex = 589; + ClientMessage encoded = CachePutIfAbsentCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutCodec_decodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CachePutCodec.RequestParameters parameters = CachePutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(null, parameters.expiryPolicy)); + assertTrue(isEqual(aBoolean, parameters.get)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CachePutCodec_encodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage encoded = CachePutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 592; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveEntryListenerCodec.RequestParameters parameters = CacheRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 593; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 594; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveInvalidationListenerCodec.RequestParameters parameters = CacheRemoveInvalidationListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 595; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 596; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveCodec.RequestParameters parameters = CacheRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(null, parameters.currentValue)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 597; + ClientMessage encoded = CacheRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 598; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheReplaceCodec.RequestParameters parameters = CacheReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(null, parameters.oldValue)); + assertTrue(isEqual(aData, parameters.newValue)); + assertTrue(isEqual(null, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 599; + ClientMessage encoded = CacheReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeRequest() { + int fileClientMessageIndex = 600; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeResponse() { + int fileClientMessageIndex = 601; + ClientMessage encoded = CacheSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 602; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddPartitionLostListenerCodec.RequestParameters parameters = CacheAddPartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 603; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEvent() { + int fileClientMessageIndex = 604; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeCachePartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 605; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemovePartitionLostListenerCodec.RequestParameters parameters = CacheRemovePartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 606; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeRequest() { + int fileClientMessageIndex = 607; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CachePutAllCodec.RequestParameters parameters = CachePutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + assertTrue(isEqual(null, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CachePutAllCodec_encodeResponse() { + int fileClientMessageIndex = 608; + ClientMessage encoded = CachePutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 609; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateEntriesCodec.RequestParameters parameters = CacheIterateEntriesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_CacheIterateEntriesCodec_encodeResponse() { + int fileClientMessageIndex = 610; + ClientMessage encoded = CacheIterateEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 611; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodec.RequestParameters parameters = CacheAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 612; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidationEvent() { + int fileClientMessageIndex = 613; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheInvalidationEvent(aString, null, null, aUUID, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheBatchInvalidationEvent() { + int fileClientMessageIndex = 614; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheBatchInvalidationEvent(aString, aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 615; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = CacheFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aListOfStrings, parameters.names)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 617; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 618; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 619; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEventJournalReadCodec.RequestParameters parameters = CacheEventJournalReadCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.startSequence)); + assertTrue(isEqual(anInt, parameters.minSize)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(null, parameters.predicate)); + assertTrue(isEqual(null, parameters.projection)); + } + + @Test + public void test_CacheEventJournalReadCodec_encodeResponse() { + int fileClientMessageIndex = 620; + ClientMessage encoded = CacheEventJournalReadCodec.encodeResponse(anInt, aListOfData, null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeRequest() { + int fileClientMessageIndex = 621; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheSetExpiryPolicyCodec.RequestParameters parameters = CacheSetExpiryPolicyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_encodeResponse() { + int fileClientMessageIndex = 622; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anXid, XATransactionClearRemoteCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeResponse() { + int fileClientMessageIndex = 624; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeRequest() { + int fileClientMessageIndex = 625; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeResponse() { + int fileClientMessageIndex = 626; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeResponse(aListOfXids); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeRequest() { + int fileClientMessageIndex = 627; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + XATransactionFinalizeCodec.RequestParameters parameters = XATransactionFinalizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(anXid, parameters.xid)); + assertTrue(isEqual(aBoolean, parameters.isCommit)); + } + + @Test + public void test_XATransactionFinalizeCodec_encodeResponse() { + int fileClientMessageIndex = 628; + ClientMessage encoded = XATransactionFinalizeCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 629; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + XATransactionCommitCodec.RequestParameters parameters = XATransactionCommitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.transactionId)); + assertTrue(isEqual(aBoolean, parameters.onePhase)); + } + + @Test + public void test_XATransactionCommitCodec_encodeResponse() { + int fileClientMessageIndex = 630; + ClientMessage encoded = XATransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 631; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + XATransactionCreateCodec.RequestParameters parameters = XATransactionCreateCodec.decodeRequest(fromFile); + assertTrue(isEqual(anXid, parameters.xid)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_XATransactionCreateCodec_encodeResponse() { + int fileClientMessageIndex = 632; + ClientMessage encoded = XATransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeRequest() { + int fileClientMessageIndex = 633; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionPrepareCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeResponse() { + int fileClientMessageIndex = 634; + ClientMessage encoded = XATransactionPrepareCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 635; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionRollbackCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionRollbackCodec_encodeResponse() { + int fileClientMessageIndex = 636; + ClientMessage encoded = XATransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 637; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionCommitCodec.RequestParameters parameters = TransactionCommitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.transactionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionCommitCodec_encodeResponse() { + int fileClientMessageIndex = 638; + ClientMessage encoded = TransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 639; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionCreateCodec.RequestParameters parameters = TransactionCreateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.timeout)); + assertTrue(isEqual(anInt, parameters.durability)); + assertTrue(isEqual(anInt, parameters.transactionType)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionCreateCodec_encodeResponse() { + int fileClientMessageIndex = 640; + ClientMessage encoded = TransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 641; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionRollbackCodec.RequestParameters parameters = TransactionRollbackCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.transactionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionRollbackCodec_encodeResponse() { + int fileClientMessageIndex = 642; + ClientMessage encoded = TransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { + int fileClientMessageIndex = 643; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryPublisherCreateWithValueCodec.RequestParameters parameters = ContinuousQueryPublisherCreateWithValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(anInt, parameters.batchSize)); + assertTrue(isEqual(anInt, parameters.bufferSize)); + assertTrue(isEqual(aLong, parameters.delaySeconds)); + assertTrue(isEqual(aBoolean, parameters.populate)); + assertTrue(isEqual(aBoolean, parameters.coalesce)); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeResponse() { + int fileClientMessageIndex = 644; + ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { + int fileClientMessageIndex = 645; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryPublisherCreateCodec.RequestParameters parameters = ContinuousQueryPublisherCreateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(anInt, parameters.batchSize)); + assertTrue(isEqual(anInt, parameters.bufferSize)); + assertTrue(isEqual(aLong, parameters.delaySeconds)); + assertTrue(isEqual(aBoolean, parameters.populate)); + assertTrue(isEqual(aBoolean, parameters.coalesce)); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_encodeResponse() { + int fileClientMessageIndex = 646; + ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryMadePublishableCodec.RequestParameters parameters = ContinuousQueryMadePublishableCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_encodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodec.RequestParameters parameters = ContinuousQueryAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.listenerName)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { + int fileClientMessageIndex = 651; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheSingleEvent(aQueryCacheEventData); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { + int fileClientMessageIndex = 652; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheBatchEvent(aListOfQueryCacheEventData, aString, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQuerySetReadCursorCodec.RequestParameters parameters = ContinuousQuerySetReadCursorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + assertTrue(isEqual(aLong, parameters.sequence)); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_encodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryDestroyCacheCodec.RequestParameters parameters = ContinuousQueryDestroyCacheCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_encodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeRequest() { + int fileClientMessageIndex = 657; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeResponse() { + int fileClientMessageIndex = 658; + ClientMessage encoded = RingbufferSizeCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 659; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferTailSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 660; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 661; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferHeadSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 662; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 663; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 664; + ClientMessage encoded = RingbufferCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 665; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 666; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferAddCodec.RequestParameters parameters = RingbufferAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.overflowPolicy)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_RingbufferAddCodec_encodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage encoded = RingbufferAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeRequest() { + int fileClientMessageIndex = 669; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferReadOneCodec.RequestParameters parameters = RingbufferReadOneCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sequence)); + } + + @Test + public void test_RingbufferReadOneCodec_encodeResponse() { + int fileClientMessageIndex = 670; + ClientMessage encoded = RingbufferReadOneCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 671; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferAddAllCodec.RequestParameters parameters = RingbufferAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + assertTrue(isEqual(anInt, parameters.overflowPolicy)); + } + + @Test + public void test_RingbufferAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 672; + ClientMessage encoded = RingbufferAddAllCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadManyCodec_decodeRequest() { + int fileClientMessageIndex = 673; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferReadManyCodec.RequestParameters parameters = RingbufferReadManyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.startSequence)); + assertTrue(isEqual(anInt, parameters.minCount)); + assertTrue(isEqual(anInt, parameters.maxCount)); + assertTrue(isEqual(null, parameters.filter)); + } + + @Test + public void test_RingbufferReadManyCodec_encodeResponse() { + int fileClientMessageIndex = 674; + ClientMessage encoded = RingbufferReadManyCodec.encodeResponse(anInt, aListOfData, null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 675; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 676; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 677; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 678; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorSubmitToPartitionCodec.RequestParameters parameters = DurableExecutorSubmitToPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.callable)); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { + int fileClientMessageIndex = 681; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorRetrieveResultCodec.RequestParameters parameters = DurableExecutorRetrieveResultCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.sequence)); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_encodeResponse() { + int fileClientMessageIndex = 682; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 683; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorDisposeResultCodec.RequestParameters parameters = DurableExecutorDisposeResultCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.sequence)); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_encodeResponse() { + int fileClientMessageIndex = 684; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 685; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorRetrieveAndDisposeResultCodec.RequestParameters parameters = DurableExecutorRetrieveAndDisposeResultCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.sequence)); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeResponse() { + int fileClientMessageIndex = 686; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CardinalityEstimatorAddCodec.RequestParameters parameters = CardinalityEstimatorAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.hash)); + } + + @Test + public void test_CardinalityEstimatorAddCodec_encodeResponse() { + int fileClientMessageIndex = 688; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeRequest() { + int fileClientMessageIndex = 689; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CardinalityEstimatorEstimateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { + int fileClientMessageIndex = 690; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 691; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorShutdownCodec.RequestParameters parameters = ScheduledExecutorShutdownCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 692; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 693; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorSubmitToPartitionCodec.RequestParameters parameters = ScheduledExecutorSubmitToPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aByte, parameters.type)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aData, parameters.task)); + assertTrue(isEqual(aLong, parameters.initialDelayInMillis)); + assertTrue(isEqual(aLong, parameters.periodInMillis)); + assertTrue(parameters.isAutoDisposableExists); + assertTrue(isEqual(aBoolean, parameters.autoDisposable)); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 694; + ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 695; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorSubmitToMemberCodec.RequestParameters parameters = ScheduledExecutorSubmitToMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.type)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aData, parameters.task)); + assertTrue(isEqual(aLong, parameters.initialDelayInMillis)); + assertTrue(isEqual(aLong, parameters.periodInMillis)); + assertTrue(parameters.isAutoDisposableExists); + assertTrue(isEqual(aBoolean, parameters.autoDisposable)); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_encodeResponse() { + int fileClientMessageIndex = 696; + ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeRequest() { + int fileClientMessageIndex = 697; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ScheduledExecutorGetAllScheduledFuturesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { + int fileClientMessageIndex = 698; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeResponse(aListOfScheduledTaskHandler); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 699; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 700; + ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 701; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 702; + ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 703; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetDelayFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 704; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 705; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetDelayFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 706; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 707; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorCancelFromPartitionCodec.RequestParameters parameters = ScheduledExecutorCancelFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aBoolean, parameters.mayInterruptIfRunning)); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 708; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 709; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorCancelFromMemberCodec.RequestParameters parameters = ScheduledExecutorCancelFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aBoolean, parameters.mayInterruptIfRunning)); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 710; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 711; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsCancelledFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 712; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 713; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsCancelledFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 714; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 715; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsDoneFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 716; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 717; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsDoneFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 718; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 719; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetResultFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetResultFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 720; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 721; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetResultFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetResultFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 722; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 723; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorDisposeFromPartitionCodec.RequestParameters parameters = ScheduledExecutorDisposeFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 724; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 725; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorDisposeFromMemberCodec.RequestParameters parameters = ScheduledExecutorDisposeFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 726; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 727; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddMultiMapConfigCodec.RequestParameters parameters = DynamicConfigAddMultiMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.collectionType)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + assertTrue(isEqual(aBoolean, parameters.binary)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 728; + ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { + int fileClientMessageIndex = 729; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddRingbufferConfigCodec.RequestParameters parameters = DynamicConfigAddRingbufferConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.capacity)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(null, parameters.ringbufferStoreConfig)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_encodeResponse() { + int fileClientMessageIndex = 730; + ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 731; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddCardinalityEstimatorConfigCodec.RequestParameters parameters = DynamicConfigAddCardinalityEstimatorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 732; + ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_decodeRequest() { + int fileClientMessageIndex = 733; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddListConfigCodec.RequestParameters parameters = DynamicConfigAddListConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_encodeResponse() { + int fileClientMessageIndex = 734; + ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 735; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddSetConfigCodec.RequestParameters parameters = DynamicConfigAddSetConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_encodeResponse() { + int fileClientMessageIndex = 736; + ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 737; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddReplicatedMapConfigCodec.RequestParameters parameters = DynamicConfigAddReplicatedMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(aBoolean, parameters.asyncFillup)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 738; + ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 739; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddTopicConfigCodec.RequestParameters parameters = DynamicConfigAddTopicConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.globalOrderingEnabled)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aBoolean, parameters.multiThreadingEnabled)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_encodeResponse() { + int fileClientMessageIndex = 740; + ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 741; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddExecutorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.poolSize)); + assertTrue(isEqual(anInt, parameters.queueCapacity)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 742; + ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 743; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddDurableExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddDurableExecutorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.poolSize)); + assertTrue(isEqual(anInt, parameters.durability)); + assertTrue(isEqual(anInt, parameters.capacity)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(parameters.isStatisticsEnabledExists); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 744; + ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 745; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddScheduledExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddScheduledExecutorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.poolSize)); + assertTrue(isEqual(anInt, parameters.durability)); + assertTrue(isEqual(anInt, parameters.capacity)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(parameters.isStatisticsEnabledExists); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(parameters.isCapacityPolicyExists); + assertTrue(isEqual(aByte, parameters.capacityPolicy)); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 746; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { + int fileClientMessageIndex = 747; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddQueueConfigCodec.RequestParameters parameters = DynamicConfigAddQueueConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(anInt, parameters.emptyQueueTtl)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(null, parameters.queueStoreConfig)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(parameters.isPriorityComparatorClassNameExists); + assertTrue(isEqual(null, parameters.priorityComparatorClassName)); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_encodeResponse() { + int fileClientMessageIndex = 748; + ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 749; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddMapConfigCodec.RequestParameters parameters = DynamicConfigAddMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(anInt, parameters.maxIdleSeconds)); + assertTrue(isEqual(null, parameters.evictionConfig)); + assertTrue(isEqual(aBoolean, parameters.readBackupData)); + assertTrue(isEqual(aString, parameters.cacheDeserializedValues)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + assertTrue(isEqual(null, parameters.partitionLostListenerConfigs)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(null, parameters.mapStoreConfig)); + assertTrue(isEqual(null, parameters.nearCacheConfig)); + assertTrue(isEqual(null, parameters.wanReplicationRef)); + assertTrue(isEqual(null, parameters.indexConfigs)); + assertTrue(isEqual(null, parameters.attributeConfigs)); + assertTrue(isEqual(null, parameters.queryCacheConfigs)); + assertTrue(isEqual(null, parameters.partitioningStrategyClassName)); + assertTrue(isEqual(null, parameters.partitioningStrategyImplementation)); + assertTrue(isEqual(null, parameters.hotRestartConfig)); + assertTrue(isEqual(null, parameters.eventJournalConfig)); + assertTrue(isEqual(null, parameters.merkleTreeConfig)); + assertTrue(isEqual(anInt, parameters.metadataPolicy)); + assertTrue(parameters.isPerEntryStatsEnabledExists); + assertTrue(isEqual(aBoolean, parameters.perEntryStatsEnabled)); + assertTrue(parameters.isDataPersistenceConfigExists); + assertTrue(isEqual(aDataPersistenceConfig, parameters.dataPersistenceConfig)); + assertTrue(parameters.isTieredStoreConfigExists); + assertTrue(isEqual(aTieredStoreConfig, parameters.tieredStoreConfig)); + assertTrue(parameters.isPartitioningAttributeConfigsExists); + assertTrue(isEqual(null, parameters.partitioningAttributeConfigs)); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 750; + ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 751; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddReliableTopicConfigCodec.RequestParameters parameters = DynamicConfigAddReliableTopicConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.readBatchSize)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.topicOverloadPolicy)); + assertTrue(isEqual(null, parameters.executor)); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_encodeResponse() { + int fileClientMessageIndex = 752; + ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { + int fileClientMessageIndex = 753; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddCacheConfigCodec.RequestParameters parameters = DynamicConfigAddCacheConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(null, parameters.keyType)); + assertTrue(isEqual(null, parameters.valueType)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aBoolean, parameters.managementEnabled)); + assertTrue(isEqual(aBoolean, parameters.readThrough)); + assertTrue(isEqual(aBoolean, parameters.writeThrough)); + assertTrue(isEqual(null, parameters.cacheLoaderFactory)); + assertTrue(isEqual(null, parameters.cacheWriterFactory)); + assertTrue(isEqual(null, parameters.cacheLoader)); + assertTrue(isEqual(null, parameters.cacheWriter)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + assertTrue(isEqual(null, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(isEqual(aBoolean, parameters.disablePerEntryInvalidationEvents)); + assertTrue(isEqual(null, parameters.partitionLostListenerConfigs)); + assertTrue(isEqual(null, parameters.expiryPolicyFactoryClassName)); + assertTrue(isEqual(null, parameters.timedExpiryPolicyFactoryConfig)); + assertTrue(isEqual(null, parameters.cacheEntryListeners)); + assertTrue(isEqual(null, parameters.evictionConfig)); + assertTrue(isEqual(null, parameters.wanReplicationRef)); + assertTrue(isEqual(null, parameters.eventJournalConfig)); + assertTrue(isEqual(null, parameters.hotRestartConfig)); + assertTrue(parameters.isMerkleTreeConfigExists); + assertTrue(isEqual(null, parameters.merkleTreeConfig)); + assertTrue(parameters.isDataPersistenceConfigExists); + assertTrue(isEqual(aDataPersistenceConfig, parameters.dataPersistenceConfig)); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { + int fileClientMessageIndex = 754; + ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 755; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddFlakeIdGeneratorConfigCodec.RequestParameters parameters = DynamicConfigAddFlakeIdGeneratorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.prefetchCount)); + assertTrue(isEqual(aLong, parameters.prefetchValidity)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aLong, parameters.nodeIdOffset)); + assertTrue(isEqual(aLong, parameters.epochStart)); + assertTrue(isEqual(anInt, parameters.bitsSequence)); + assertTrue(isEqual(anInt, parameters.bitsNodeId)); + assertTrue(isEqual(aLong, parameters.allowedFutureMillis)); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 756; + ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddPNCounterConfigCodec.RequestParameters parameters = DynamicConfigAddPNCounterConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.replicaCount)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(null, parameters.splitBrainProtectionName)); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_encodeResponse() { + int fileClientMessageIndex = 758; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_decodeRequest() { + int fileClientMessageIndex = 759; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddDataConnectionConfigCodec.RequestParameters parameters = DynamicConfigAddDataConnectionConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.type)); + assertTrue(isEqual(aBoolean, parameters.shared)); + assertTrue(isEqual(aMapOfStringToString, parameters.properties)); + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_encodeResponse() { + int fileClientMessageIndex = 760; + ClientMessage encoded = DynamicConfigAddDataConnectionConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { + int fileClientMessageIndex = 761; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FlakeIdGeneratorNewIdBatchCodec.RequestParameters parameters = FlakeIdGeneratorNewIdBatchCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.batchSize)); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_encodeResponse() { + int fileClientMessageIndex = 762; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeResponse(aLong, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeRequest() { + int fileClientMessageIndex = 763; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterGetCodec.RequestParameters parameters = PNCounterGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(aUUID, parameters.targetReplicaUUID)); + } + + @Test + public void test_PNCounterGetCodec_encodeResponse() { + int fileClientMessageIndex = 764; + ClientMessage encoded = PNCounterGetCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterAddCodec_decodeRequest() { + int fileClientMessageIndex = 765; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterAddCodec.RequestParameters parameters = PNCounterAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.delta)); + assertTrue(isEqual(aBoolean, parameters.getBeforeUpdate)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(aUUID, parameters.targetReplicaUUID)); + } + + @Test + public void test_PNCounterAddCodec_encodeResponse() { + int fileClientMessageIndex = 766; + ClientMessage encoded = PNCounterAddCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, PNCounterGetConfiguredReplicaCountCodec.decodeRequest(fromFile))); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeRequest() { + int fileClientMessageIndex = 769; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CPGroupCreateCPGroupCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeResponse() { + int fileClientMessageIndex = 770; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeResponse(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { + int fileClientMessageIndex = 771; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPGroupDestroyCPObjectCodec.RequestParameters parameters = CPGroupDestroyCPObjectCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.serviceName)); + assertTrue(isEqual(aString, parameters.objectName)); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_encodeResponse() { + int fileClientMessageIndex = 772; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionCreateSessionCodec.RequestParameters parameters = CPSessionCreateSessionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.endpointName)); + } + + @Test + public void test_CPSessionCreateSessionCodec_encodeResponse() { + int fileClientMessageIndex = 774; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeResponse(aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeRequest() { + int fileClientMessageIndex = 775; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionCloseSessionCodec.RequestParameters parameters = CPSessionCloseSessionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aLong, parameters.sessionId)); + } + + @Test + public void test_CPSessionCloseSessionCodec_encodeResponse() { + int fileClientMessageIndex = 776; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { + int fileClientMessageIndex = 777; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionHeartbeatSessionCodec.RequestParameters parameters = CPSessionHeartbeatSessionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aLong, parameters.sessionId)); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_encodeResponse() { + int fileClientMessageIndex = 778; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeRequest() { + int fileClientMessageIndex = 779; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPSessionGenerateThreadIdCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { + int fileClientMessageIndex = 780; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCReadMetricsCodec.RequestParameters parameters = MCReadMetricsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aLong, parameters.fromSequence)); + } + + @Test + public void test_MCReadMetricsCodec_encodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage encoded = MCReadMetricsCodec.encodeResponse(aListOfLongToByteArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeRequest() { + int fileClientMessageIndex = 783; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MCChangeClusterStateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCChangeClusterStateCodec_encodeResponse() { + int fileClientMessageIndex = 784; + ClientMessage encoded = MCChangeClusterStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 785; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMapConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 786; + ClientMessage encoded = MCGetMapConfigCodec.encodeResponse(anInt, anInt, anInt, anInt, anInt, anInt, anInt, aBoolean, anInt, aString, aListOfIndexConfigs); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 787; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCUpdateMapConfigCodec.RequestParameters parameters = MCUpdateMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(anInt, parameters.maxIdleSeconds)); + assertTrue(isEqual(anInt, parameters.evictionPolicy)); + assertTrue(isEqual(aBoolean, parameters.readBackupData)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(anInt, parameters.maxSizePolicy)); + } + + @Test + public void test_MCUpdateMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 788; + ClientMessage encoded = MCUpdateMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeRequest() { + int fileClientMessageIndex = 789; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage encoded = MCGetMemberConfigCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeRequest() { + int fileClientMessageIndex = 791; + } + + @Test + public void test_MCRunGcCodec_encodeResponse() { + int fileClientMessageIndex = 792; + ClientMessage encoded = MCRunGcCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeRequest() { + int fileClientMessageIndex = 793; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCGetThreadDumpCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetThreadDumpCodec_encodeResponse() { + int fileClientMessageIndex = 794; + ClientMessage encoded = MCGetThreadDumpCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeRequest() { + int fileClientMessageIndex = 795; + } + + @Test + public void test_MCShutdownMemberCodec_encodeResponse() { + int fileClientMessageIndex = 796; + ClientMessage encoded = MCShutdownMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeRequest() { + int fileClientMessageIndex = 797; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeResponse() { + int fileClientMessageIndex = 798; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeRequest() { + int fileClientMessageIndex = 799; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeResponse() { + int fileClientMessageIndex = 800; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeResponse(aListOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeRequest() { + int fileClientMessageIndex = 801; + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeResponse() { + int fileClientMessageIndex = 802; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 803; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCMatchMCConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeResponse() { + int fileClientMessageIndex = 804; + ClientMessage encoded = MCMatchMCConfigCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 805; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCApplyMCConfigCodec.RequestParameters parameters = MCApplyMCConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.eTag)); + assertTrue(isEqual(anInt, parameters.clientBwListMode)); + assertTrue(isEqual(aListOfClientBwListEntries, parameters.clientBwListEntries)); + } + + @Test + public void test_MCApplyMCConfigCodec_encodeResponse() { + int fileClientMessageIndex = 806; + ClientMessage encoded = MCApplyMCConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 807; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 808; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeResponse(aByte, aString, null, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeRequest() { + int fileClientMessageIndex = 809; + } + + @Test + public void test_MCShutdownClusterCodec_encodeResponse() { + int fileClientMessageIndex = 810; + ClientMessage encoded = MCShutdownClusterCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeRequest() { + int fileClientMessageIndex = 811; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCChangeClusterVersionCodec.RequestParameters parameters = MCChangeClusterVersionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aByte, parameters.majorVersion)); + assertTrue(isEqual(aByte, parameters.minorVersion)); + } + + @Test + public void test_MCChangeClusterVersionCodec_encodeResponse() { + int fileClientMessageIndex = 812; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeRequest() { + int fileClientMessageIndex = 813; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCRunScriptCodec.RequestParameters parameters = MCRunScriptCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.engine)); + assertTrue(isEqual(aString, parameters.script)); + } + + @Test + public void test_MCRunScriptCodec_encodeResponse() { + int fileClientMessageIndex = 814; + ClientMessage encoded = MCRunScriptCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeRequest() { + int fileClientMessageIndex = 815; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCRunConsoleCommandCodec.RequestParameters parameters = MCRunConsoleCommandCodec.decodeRequest(fromFile); + assertTrue(isEqual(null, parameters.namespace)); + assertTrue(isEqual(aString, parameters.command)); + } + + @Test + public void test_MCRunConsoleCommandCodec_encodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeRequest() { + int fileClientMessageIndex = 817; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCChangeWanReplicationStateCodec.RequestParameters parameters = MCChangeWanReplicationStateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + assertTrue(isEqual(aByte, parameters.newState)); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_encodeResponse() { + int fileClientMessageIndex = 818; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeRequest() { + int fileClientMessageIndex = 819; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCClearWanQueuesCodec.RequestParameters parameters = MCClearWanQueuesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + } + + @Test + public void test_MCClearWanQueuesCodec_encodeResponse() { + int fileClientMessageIndex = 820; + ClientMessage encoded = MCClearWanQueuesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCAddWanBatchPublisherConfigCodec.RequestParameters parameters = MCAddWanBatchPublisherConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.targetCluster)); + assertTrue(isEqual(null, parameters.publisherId)); + assertTrue(isEqual(aString, parameters.endpoints)); + assertTrue(isEqual(anInt, parameters.queueCapacity)); + assertTrue(isEqual(anInt, parameters.batchSize)); + assertTrue(isEqual(anInt, parameters.batchMaxDelayMillis)); + assertTrue(isEqual(anInt, parameters.responseTimeoutMillis)); + assertTrue(isEqual(anInt, parameters.ackType)); + assertTrue(isEqual(anInt, parameters.queueFullBehavior)); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_encodeResponse() { + int fileClientMessageIndex = 822; + ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeResponse(aListOfStrings, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeRequest() { + int fileClientMessageIndex = 823; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCWanSyncMapCodec.RequestParameters parameters = MCWanSyncMapCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + assertTrue(isEqual(anInt, parameters.wanSyncType)); + assertTrue(isEqual(null, parameters.mapName)); + } + + @Test + public void test_MCWanSyncMapCodec_encodeResponse() { + int fileClientMessageIndex = 824; + ClientMessage encoded = MCWanSyncMapCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeRequest() { + int fileClientMessageIndex = 825; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCCheckWanConsistencyCodec.RequestParameters parameters = MCCheckWanConsistencyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + assertTrue(isEqual(null, parameters.mapName)); + } + + @Test + public void test_MCCheckWanConsistencyCodec_encodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeRequest() { + int fileClientMessageIndex = 827; + } + + @Test + public void test_MCPollMCEventsCodec_encodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage encoded = MCPollMCEventsCodec.encodeResponse(aListOfMCEvents); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeRequest() { + int fileClientMessageIndex = 829; + } + + @Test + public void test_MCGetCPMembersCodec_encodeResponse() { + int fileClientMessageIndex = 830; + ClientMessage encoded = MCGetCPMembersCodec.encodeResponse(aListOfUUIDToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 831; + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 832; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 833; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCRemoveCPMemberCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 834; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeRequest() { + int fileClientMessageIndex = 835; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeResponse() { + int fileClientMessageIndex = 836; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeRequest() { + int fileClientMessageIndex = 837; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeResponse() { + int fileClientMessageIndex = 838; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeRequest() { + int fileClientMessageIndex = 839; + } + + @Test + public void test_MCTriggerForceStartCodec_encodeResponse() { + int fileClientMessageIndex = 840; + ClientMessage encoded = MCTriggerForceStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 841; + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 842; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 843; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 844; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_decodeRequest() { + int fileClientMessageIndex = 845; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCResetQueueAgeStatisticsCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_encodeResponse() { + int fileClientMessageIndex = 846; + ClientMessage encoded = MCResetQueueAgeStatisticsCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReloadConfigCodec_decodeRequest() { + int fileClientMessageIndex = 847; + } + + @Test + public void test_MCReloadConfigCodec_encodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage encoded = MCReloadConfigCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateConfigCodec_decodeRequest() { + int fileClientMessageIndex = 849; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCUpdateConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCUpdateConfigCodec_encodeResponse() { + int fileClientMessageIndex = 850; + ClientMessage encoded = MCUpdateConfigCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecute_reservedCodec_decodeRequest() { + int fileClientMessageIndex = 851; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecute_reservedCodec.RequestParameters parameters = SqlExecute_reservedCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.sql)); + assertTrue(isEqual(aListOfData, parameters.parameters)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + } + + @Test + public void test_SqlExecute_reservedCodec_encodeResponse() { + int fileClientMessageIndex = 852; + ClientMessage encoded = SqlExecute_reservedCodec.encodeResponse(null, null, null, aBoolean, aLong, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetch_reservedCodec_decodeRequest() { + int fileClientMessageIndex = 853; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetch_reservedCodec.RequestParameters parameters = SqlFetch_reservedCodec.decodeRequest(fromFile); + assertTrue(isEqual(anSqlQueryId, parameters.queryId)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + } + + @Test + public void test_SqlFetch_reservedCodec_encodeResponse() { + int fileClientMessageIndex = 854; + ClientMessage encoded = SqlFetch_reservedCodec.encodeResponse(null, aBoolean, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeRequest() { + int fileClientMessageIndex = 855; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anSqlQueryId, SqlCloseCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SqlCloseCodec_encodeResponse() { + int fileClientMessageIndex = 856; + ClientMessage encoded = SqlCloseCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeRequest() { + int fileClientMessageIndex = 857; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecuteCodec.RequestParameters parameters = SqlExecuteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.sql)); + assertTrue(isEqual(aListOfData, parameters.parameters)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + assertTrue(isEqual(null, parameters.schema)); + assertTrue(isEqual(aByte, parameters.expectedResultType)); + assertTrue(isEqual(anSqlQueryId, parameters.queryId)); + assertTrue(parameters.isSkipUpdateStatisticsExists); + assertTrue(isEqual(aBoolean, parameters.skipUpdateStatistics)); + } + + @Test + public void test_SqlExecuteCodec_encodeResponse() { + int fileClientMessageIndex = 858; + ClientMessage encoded = SqlExecuteCodec.encodeResponse(null, null, aLong, null, aBoolean, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeRequest() { + int fileClientMessageIndex = 859; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetchCodec.RequestParameters parameters = SqlFetchCodec.decodeRequest(fromFile); + assertTrue(isEqual(anSqlQueryId, parameters.queryId)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + } + + @Test + public void test_SqlFetchCodec_encodeResponse() { + int fileClientMessageIndex = 860; + ClientMessage encoded = SqlFetchCodec.encodeResponse(null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlMappingDdlCodec_decodeRequest() { + int fileClientMessageIndex = 861; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SqlMappingDdlCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SqlMappingDdlCodec_encodeResponse() { + int fileClientMessageIndex = 862; + ClientMessage encoded = SqlMappingDdlCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 863; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 864; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEvent() { + int fileClientMessageIndex = 865; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeMembershipEventEvent(aCpMember, aByte); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 866; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 867; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 868; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 869; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailabilityEventEvent() { + int fileClientMessageIndex = 870; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeGroupAvailabilityEventEvent(aRaftGroupId, aListOfCpMembers, aListOfCpMembers); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 871; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 872; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCodec_decodeRequest() { + int fileClientMessageIndex = 873; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCodec.RequestParameters parameters = ExperimentalAuthenticationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(null, parameters.username)); + assertTrue(isEqual(null, parameters.password)); + assertTrue(isEqual(null, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ExperimentalAuthenticationCodec_encodeResponse() { + int fileClientMessageIndex = 874; + ClientMessage encoded = ExperimentalAuthenticationCodec.encodeResponse(aByte, null, null, aByte, aString, anInt, aUUID, aBoolean, null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_decodeRequest() { + int fileClientMessageIndex = 875; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCustomCodec.RequestParameters parameters = ExperimentalAuthenticationCustomCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(aByteArray, parameters.credentials)); + assertTrue(isEqual(null, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_encodeResponse() { + int fileClientMessageIndex = 876; + ClientMessage encoded = ExperimentalAuthenticationCustomCodec.encodeResponse(aByte, null, null, aByte, aString, anInt, aUUID, aBoolean, null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_decodeRequest() { + int fileClientMessageIndex = 877; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalTpcAuthenticationCodec.RequestParameters parameters = ExperimentalTpcAuthenticationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aByteArray, parameters.token)); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_encodeResponse() { + int fileClientMessageIndex = 878; + ClientMessage encoded = ExperimentalTpcAuthenticationCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetSubmitJobCodec_decodeRequest() { + int fileClientMessageIndex = 879; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetSubmitJobCodec.RequestParameters parameters = JetSubmitJobCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aData, parameters.dag)); + assertTrue(isEqual(null, parameters.jobConfig)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(null, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetSubmitJobCodec_encodeResponse() { + int fileClientMessageIndex = 880; + ClientMessage encoded = JetSubmitJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetTerminateJobCodec_decodeRequest() { + int fileClientMessageIndex = 881; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetTerminateJobCodec.RequestParameters parameters = JetTerminateJobCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(anInt, parameters.terminateMode)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(null, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetTerminateJobCodec_encodeResponse() { + int fileClientMessageIndex = 882; + ClientMessage encoded = JetTerminateJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobStatusCodec_decodeRequest() { + int fileClientMessageIndex = 883; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobStatusCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetGetJobStatusCodec_encodeResponse() { + int fileClientMessageIndex = 884; + ClientMessage encoded = JetGetJobStatusCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobIdsCodec_decodeRequest() { + int fileClientMessageIndex = 885; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobIdsCodec.RequestParameters parameters = JetGetJobIdsCodec.decodeRequest(fromFile); + assertTrue(parameters.isOnlyNameExists); + assertTrue(isEqual(null, parameters.onlyName)); + assertTrue(parameters.isOnlyJobIdExists); + assertTrue(isEqual(aLong, parameters.onlyJobId)); + } + + @Test + public void test_JetGetJobIdsCodec_encodeResponse() { + int fileClientMessageIndex = 886; + ClientMessage encoded = JetGetJobIdsCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetJoinSubmittedJobCodec_decodeRequest() { + int fileClientMessageIndex = 887; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetJoinSubmittedJobCodec.RequestParameters parameters = JetJoinSubmittedJobCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(null, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetJoinSubmittedJobCodec_encodeResponse() { + int fileClientMessageIndex = 888; + ClientMessage encoded = JetJoinSubmittedJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_decodeRequest() { + int fileClientMessageIndex = 889; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobSubmissionTimeCodec.RequestParameters parameters = JetGetJobSubmissionTimeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(null, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_encodeResponse() { + int fileClientMessageIndex = 890; + ClientMessage encoded = JetGetJobSubmissionTimeCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobConfigCodec_decodeRequest() { + int fileClientMessageIndex = 891; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobConfigCodec.RequestParameters parameters = JetGetJobConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(null, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetGetJobConfigCodec_encodeResponse() { + int fileClientMessageIndex = 892; + ClientMessage encoded = JetGetJobConfigCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetResumeJobCodec_decodeRequest() { + int fileClientMessageIndex = 893; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetResumeJobCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetResumeJobCodec_encodeResponse() { + int fileClientMessageIndex = 894; + ClientMessage encoded = JetResumeJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExportSnapshotCodec_decodeRequest() { + int fileClientMessageIndex = 895; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetExportSnapshotCodec.RequestParameters parameters = JetExportSnapshotCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.cancelJob)); + } + + @Test + public void test_JetExportSnapshotCodec_encodeResponse() { + int fileClientMessageIndex = 896; + ClientMessage encoded = JetExportSnapshotCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSummaryListCodec_decodeRequest() { + int fileClientMessageIndex = 897; + } + + @Test + public void test_JetGetJobSummaryListCodec_encodeResponse() { + int fileClientMessageIndex = 898; + ClientMessage encoded = JetGetJobSummaryListCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExistsDistributedObjectCodec_decodeRequest() { + int fileClientMessageIndex = 899; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetExistsDistributedObjectCodec.RequestParameters parameters = JetExistsDistributedObjectCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.serviceName)); + assertTrue(isEqual(aString, parameters.objectName)); + } + + @Test + public void test_JetExistsDistributedObjectCodec_encodeResponse() { + int fileClientMessageIndex = 900; + ClientMessage encoded = JetExistsDistributedObjectCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobMetricsCodec_decodeRequest() { + int fileClientMessageIndex = 901; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobMetricsCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetGetJobMetricsCodec_encodeResponse() { + int fileClientMessageIndex = 902; + ClientMessage encoded = JetGetJobMetricsCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_decodeRequest() { + int fileClientMessageIndex = 903; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobSuspensionCauseCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_encodeResponse() { + int fileClientMessageIndex = 904; + ClientMessage encoded = JetGetJobSuspensionCauseCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_decodeRequest() { + int fileClientMessageIndex = 905; + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_encodeResponse() { + int fileClientMessageIndex = 906; + ClientMessage encoded = JetGetJobAndSqlSummaryListCodec.encodeResponse(aListJobAndSqlSummary); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetIsJobUserCancelledCodec_decodeRequest() { + int fileClientMessageIndex = 907; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetIsJobUserCancelledCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetIsJobUserCancelledCodec_encodeResponse() { + int fileClientMessageIndex = 908; + ClientMessage encoded = JetIsJobUserCancelledCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMetaDataCodec_decodeRequest() { + int fileClientMessageIndex = 909; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetUploadJobMetaDataCodec.RequestParameters parameters = JetUploadJobMetaDataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.sessionId)); + assertTrue(isEqual(aBoolean, parameters.jarOnMember)); + assertTrue(isEqual(aString, parameters.fileName)); + assertTrue(isEqual(aString, parameters.sha256Hex)); + assertTrue(isEqual(null, parameters.snapshotName)); + assertTrue(isEqual(null, parameters.jobName)); + assertTrue(isEqual(null, parameters.mainClass)); + assertTrue(isEqual(aListOfStrings, parameters.jobParameters)); + } + + @Test + public void test_JetUploadJobMetaDataCodec_encodeResponse() { + int fileClientMessageIndex = 910; + ClientMessage encoded = JetUploadJobMetaDataCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMultipartCodec_decodeRequest() { + int fileClientMessageIndex = 911; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetUploadJobMultipartCodec.RequestParameters parameters = JetUploadJobMultipartCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.sessionId)); + assertTrue(isEqual(anInt, parameters.currentPartNumber)); + assertTrue(isEqual(anInt, parameters.totalPartNumber)); + assertTrue(isEqual(aByteArray, parameters.partData)); + assertTrue(isEqual(anInt, parameters.partSize)); + assertTrue(isEqual(aString, parameters.sha256Hex)); + } + + @Test + public void test_JetUploadJobMultipartCodec_encodeResponse() { + int fileClientMessageIndex = 912; + ClientMessage encoded = JetUploadJobMultipartCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetAddJobStatusListenerCodec_decodeRequest() { + int fileClientMessageIndex = 913; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetAddJobStatusListenerCodec.RequestParameters parameters = JetAddJobStatusListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(null, parameters.lightJobCoordinator)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_JetAddJobStatusListenerCodec_encodeResponse() { + int fileClientMessageIndex = 914; + ClientMessage encoded = JetAddJobStatusListenerCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetAddJobStatusListenerCodec_encodeJobStatusEvent() { + int fileClientMessageIndex = 915; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = JetAddJobStatusListenerCodec.encodeJobStatusEvent(aLong, anInt, anInt, null, aBoolean); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_decodeRequest() { + int fileClientMessageIndex = 916; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetRemoveJobStatusListenerCodec.RequestParameters parameters = JetRemoveJobStatusListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_encodeResponse() { + int fileClientMessageIndex = 917; + ClientMessage encoded = JetRemoveJobStatusListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUpdateJobConfigCodec_decodeRequest() { + int fileClientMessageIndex = 918; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetUpdateJobConfigCodec.RequestParameters parameters = JetUpdateJobConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aData, parameters.deltaConfig)); + } + + @Test + public void test_JetUpdateJobConfigCodec_encodeResponse() { + int fileClientMessageIndex = 919; + ClientMessage encoded = JetUpdateJobConfigCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + private void compareClientMessages(ClientMessage binaryMessage, ClientMessage encodedMessage) { + ClientMessage.Frame binaryFrame, encodedFrame; + + ClientMessage.ForwardFrameIterator binaryFrameIterator = binaryMessage.frameIterator(); + ClientMessage.ForwardFrameIterator encodedFrameIterator = encodedMessage.frameIterator(); + assertTrue("Client message that is read from the binary file does not have any frames", binaryFrameIterator.hasNext()); + + while (binaryFrameIterator.hasNext()) { + binaryFrame = binaryFrameIterator.next(); + encodedFrame = encodedFrameIterator.next(); + assertNotNull("Encoded client message has less frames.", encodedFrame); + + if (binaryFrame.isEndFrame() && !encodedFrame.isEndFrame()) { + if (encodedFrame.isBeginFrame()) { + HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + encodedFrame = HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + + boolean isFinal = binaryFrameIterator.peekNext() == null; + int flags = isFinal ? encodedFrame.flags | IS_FINAL_FLAG : encodedFrame.flags; + assertArrayEquals("Frames have different contents", binaryFrame.content, Arrays.copyOf(encodedFrame.content, binaryFrame.content.length)); + assertEquals("Frames have different flags", binaryFrame.flags, flags); + } + } +} \ No newline at end of file diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_7.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_7.java new file mode 100644 index 000000000000..50d0b5ac5ce1 --- /dev/null +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_7.java @@ -0,0 +1,8179 @@ +/* + * Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved. + * + * Licensed 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 com.hazelcast.client.protocol.compatibility; + +import com.hazelcast.client.HazelcastClientUtil; +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.ClientMessageReader; +import com.hazelcast.client.impl.protocol.codec.*; +import com.hazelcast.test.HazelcastParallelClassRunner; +import com.hazelcast.test.annotation.ParallelJVMTest; +import com.hazelcast.test.annotation.QuickTest; +import org.junit.Before; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static com.hazelcast.client.impl.protocol.ClientMessage.IS_FINAL_FLAG; +import static com.hazelcast.client.protocol.compatibility.ReferenceObjects.*; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; + +@RunWith(HazelcastParallelClassRunner.class) +@Category({QuickTest.class, ParallelJVMTest.class}) +public class MemberCompatibilityTest_2_7 { + private final List clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.7.protocol.compatibility.binary").getFile()); + InputStream inputStream = new FileInputStream(file); + byte[] data = new byte[(int) file.length()]; + inputStream.read(data); + ByteBuffer buffer = ByteBuffer.wrap(data); + ClientMessageReader reader = new ClientMessageReader(0); + while (reader.readFrom(buffer, true)) { + clientMessages.add(reader.getClientMessage()); + reader.reset(); + } + } + + @Test + public void test_ClientAuthenticationCodec_decodeRequest() { + int fileClientMessageIndex = 0; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCodec.RequestParameters parameters = ClientAuthenticationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(aString, parameters.username)); + assertTrue(isEqual(aString, parameters.password)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ClientAuthenticationCodec_encodeResponse() { + int fileClientMessageIndex = 1; + ClientMessage encoded = ClientAuthenticationCodec.encodeResponse(aByte, anAddress, aUUID, aByte, aString, anInt, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAuthenticationCustomCodec_decodeRequest() { + int fileClientMessageIndex = 2; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientAuthenticationCustomCodec.RequestParameters parameters = ClientAuthenticationCustomCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(aByteArray, parameters.credentials)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ClientAuthenticationCustomCodec_encodeResponse() { + int fileClientMessageIndex = 3; + ClientMessage encoded = ClientAuthenticationCustomCodec.encodeResponse(aByte, anAddress, aUUID, aByte, aString, anInt, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_decodeRequest() { + int fileClientMessageIndex = 4; + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodeResponse() { + int fileClientMessageIndex = 5; + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodeMembersViewEvent() { + int fileClientMessageIndex = 6; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodeMembersViewEvent(anInt, aListOfMemberInfos); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddClusterViewListenerCodec_encodePartitionsViewEvent() { + int fileClientMessageIndex = 7; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddClusterViewListenerCodec.encodePartitionsViewEvent(anInt, aListOfUUIDToListOfIntegers); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxyCodec_decodeRequest() { + int fileClientMessageIndex = 8; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientCreateProxyCodec.RequestParameters parameters = ClientCreateProxyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.serviceName)); + } + + @Test + public void test_ClientCreateProxyCodec_encodeResponse() { + int fileClientMessageIndex = 9; + ClientMessage encoded = ClientCreateProxyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDestroyProxyCodec_decodeRequest() { + int fileClientMessageIndex = 10; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientDestroyProxyCodec.RequestParameters parameters = ClientDestroyProxyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.serviceName)); + } + + @Test + public void test_ClientDestroyProxyCodec_encodeResponse() { + int fileClientMessageIndex = 11; + ClientMessage encoded = ClientDestroyProxyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 12; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientAddPartitionLostListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 13; + ClientMessage encoded = ClientAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddPartitionLostListenerCodec_encodePartitionLostEvent() { + int fileClientMessageIndex = 14; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddPartitionLostListenerCodec.encodePartitionLostEvent(anInt, anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 15; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientRemovePartitionLostListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientRemovePartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 16; + ClientMessage encoded = ClientRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientGetDistributedObjectsCodec_decodeRequest() { + int fileClientMessageIndex = 17; + } + + @Test + public void test_ClientGetDistributedObjectsCodec_encodeResponse() { + int fileClientMessageIndex = 18; + ClientMessage encoded = ClientGetDistributedObjectsCodec.encodeResponse(aListOfDistributedObjectInfo); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_decodeRequest() { + int fileClientMessageIndex = 19; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientAddDistributedObjectListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_encodeResponse() { + int fileClientMessageIndex = 20; + ClientMessage encoded = ClientAddDistributedObjectListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddDistributedObjectListenerCodec_encodeDistributedObjectEvent() { + int fileClientMessageIndex = 21; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddDistributedObjectListenerCodec.encodeDistributedObjectEvent(aString, aString, aString, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_decodeRequest() { + int fileClientMessageIndex = 22; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientRemoveDistributedObjectListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientRemoveDistributedObjectListenerCodec_encodeResponse() { + int fileClientMessageIndex = 23; + ClientMessage encoded = ClientRemoveDistributedObjectListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientPingCodec_decodeRequest() { + int fileClientMessageIndex = 24; + } + + @Test + public void test_ClientPingCodec_encodeResponse() { + int fileClientMessageIndex = 25; + ClientMessage encoded = ClientPingCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientStatisticsCodec_decodeRequest() { + int fileClientMessageIndex = 26; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientStatisticsCodec.RequestParameters parameters = ClientStatisticsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.timestamp)); + assertTrue(isEqual(aString, parameters.clientAttributes)); + assertTrue(isEqual(aByteArray, parameters.metricsBlob)); + } + + @Test + public void test_ClientStatisticsCodec_encodeResponse() { + int fileClientMessageIndex = 27; + ClientMessage encoded = ClientStatisticsCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientDeployClassesCodec_decodeRequest() { + int fileClientMessageIndex = 28; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToByteArray, ClientDeployClassesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientDeployClassesCodec_encodeResponse() { + int fileClientMessageIndex = 29; + ClientMessage encoded = ClientDeployClassesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientCreateProxiesCodec_decodeRequest() { + int fileClientMessageIndex = 30; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToString, ClientCreateProxiesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientCreateProxiesCodec_encodeResponse() { + int fileClientMessageIndex = 31; + ClientMessage encoded = ClientCreateProxiesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientLocalBackupListenerCodec_decodeRequest() { + int fileClientMessageIndex = 32; + } + + @Test + public void test_ClientLocalBackupListenerCodec_encodeResponse() { + int fileClientMessageIndex = 33; + ClientMessage encoded = ClientLocalBackupListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientLocalBackupListenerCodec_encodeBackupEvent() { + int fileClientMessageIndex = 34; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientLocalBackupListenerCodec.encodeBackupEvent(aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_decodeRequest() { + int fileClientMessageIndex = 35; + } + + @Test + public void test_ClientTriggerPartitionAssignmentCodec_encodeResponse() { + int fileClientMessageIndex = 36; + ClientMessage encoded = ClientTriggerPartitionAssignmentCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 37; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ClientAddMigrationListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 38; + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeMigrationEvent() { + int fileClientMessageIndex = 39; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeMigrationEvent(aMigrationState, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientAddMigrationListenerCodec_encodeReplicaMigrationEvent() { + int fileClientMessageIndex = 40; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ClientAddMigrationListenerCodec.encodeReplicaMigrationEvent(aMigrationState, anInt, anInt, aUUID, aUUID, aBoolean, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 41; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, ClientRemoveMigrationListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientRemoveMigrationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 42; + ClientMessage encoded = ClientRemoveMigrationListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendSchemaCodec_decodeRequest() { + int fileClientMessageIndex = 43; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aSchema, ClientSendSchemaCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientSendSchemaCodec_encodeResponse() { + int fileClientMessageIndex = 44; + ClientMessage encoded = ClientSendSchemaCodec.encodeResponse(aSetOfUUIDs); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientFetchSchemaCodec_decodeRequest() { + int fileClientMessageIndex = 45; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ClientFetchSchemaCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientFetchSchemaCodec_encodeResponse() { + int fileClientMessageIndex = 46; + ClientMessage encoded = ClientFetchSchemaCodec.encodeResponse(aSchema); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ClientSendAllSchemasCodec_decodeRequest() { + int fileClientMessageIndex = 47; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfSchemas, ClientSendAllSchemasCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ClientSendAllSchemasCodec_encodeResponse() { + int fileClientMessageIndex = 48; + ClientMessage encoded = ClientSendAllSchemasCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutCodec_decodeRequest() { + int fileClientMessageIndex = 49; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutCodec.RequestParameters parameters = MapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapPutCodec_encodeResponse() { + int fileClientMessageIndex = 50; + ClientMessage encoded = MapPutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeRequest() { + int fileClientMessageIndex = 51; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetCodec.RequestParameters parameters = MapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapGetCodec_encodeResponse() { + int fileClientMessageIndex = 52; + ClientMessage encoded = MapGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 53; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveCodec.RequestParameters parameters = MapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 54; + ClientMessage encoded = MapRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 55; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapReplaceCodec.RequestParameters parameters = MapReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 56; + ClientMessage encoded = MapReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 57; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapReplaceIfSameCodec.RequestParameters parameters = MapReplaceIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.testValue)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapReplaceIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 58; + ClientMessage encoded = MapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 59; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapContainsKeyCodec.RequestParameters parameters = MapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 60; + ClientMessage encoded = MapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapContainsValueCodec.RequestParameters parameters = MapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_MapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 62; + ClientMessage encoded = MapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 63; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveIfSameCodec.RequestParameters parameters = MapRemoveIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapRemoveIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 64; + ClientMessage encoded = MapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 65; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapDeleteCodec.RequestParameters parameters = MapDeleteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapDeleteCodec_encodeResponse() { + int fileClientMessageIndex = 66; + ClientMessage encoded = MapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeRequest() { + int fileClientMessageIndex = 67; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapFlushCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapFlushCodec_encodeResponse() { + int fileClientMessageIndex = 68; + ClientMessage encoded = MapFlushCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 69; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapTryRemoveCodec.RequestParameters parameters = MapTryRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_MapTryRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 70; + ClientMessage encoded = MapTryRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryPutCodec_decodeRequest() { + int fileClientMessageIndex = 71; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapTryPutCodec.RequestParameters parameters = MapTryPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_MapTryPutCodec_encodeResponse() { + int fileClientMessageIndex = 72; + ClientMessage encoded = MapTryPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientCodec_decodeRequest() { + int fileClientMessageIndex = 73; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutTransientCodec.RequestParameters parameters = MapPutTransientCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapPutTransientCodec_encodeResponse() { + int fileClientMessageIndex = 74; + ClientMessage encoded = MapPutTransientCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 75; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutIfAbsentCodec.RequestParameters parameters = MapPutIfAbsentCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapPutIfAbsentCodec_encodeResponse() { + int fileClientMessageIndex = 76; + ClientMessage encoded = MapPutIfAbsentCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetCodec_decodeRequest() { + int fileClientMessageIndex = 77; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSetCodec.RequestParameters parameters = MapSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapSetCodec_encodeResponse() { + int fileClientMessageIndex = 78; + ClientMessage encoded = MapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLockCodec_decodeRequest() { + int fileClientMessageIndex = 79; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapLockCodec.RequestParameters parameters = MapLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapLockCodec_encodeResponse() { + int fileClientMessageIndex = 80; + ClientMessage encoded = MapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 81; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapTryLockCodec.RequestParameters parameters = MapTryLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.lease)); + assertTrue(isEqual(aLong, parameters.timeout)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapTryLockCodec_encodeResponse() { + int fileClientMessageIndex = 82; + ClientMessage encoded = MapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 83; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapIsLockedCodec.RequestParameters parameters = MapIsLockedCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_MapIsLockedCodec_encodeResponse() { + int fileClientMessageIndex = 84; + ClientMessage encoded = MapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 85; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapUnlockCodec.RequestParameters parameters = MapUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 86; + ClientMessage encoded = MapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 87; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddInterceptorCodec.RequestParameters parameters = MapAddInterceptorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.interceptor)); + } + + @Test + public void test_MapAddInterceptorCodec_encodeResponse() { + int fileClientMessageIndex = 88; + ClientMessage encoded = MapAddInterceptorCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 89; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveInterceptorCodec.RequestParameters parameters = MapRemoveInterceptorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.id)); + } + + @Test + public void test_MapRemoveInterceptorCodec_encodeResponse() { + int fileClientMessageIndex = 90; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 91; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 92; + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 93; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 94; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 95; + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 96; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 97; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyCodec.RequestParameters parameters = MapAddEntryListenerToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 98; + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 99; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 100; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerCodec.RequestParameters parameters = MapAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 101; + ClientMessage encoded = MapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 102; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 103; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveEntryListenerCodec.RequestParameters parameters = MapRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_MapRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 104; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 105; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddPartitionLostListenerCodec.RequestParameters parameters = MapAddPartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 106; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() { + int fileClientMessageIndex = 107; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeMapPartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemovePartitionLostListenerCodec.RequestParameters parameters = MapRemovePartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 109; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeRequest() { + int fileClientMessageIndex = 110; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetEntryViewCodec.RequestParameters parameters = MapGetEntryViewCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapGetEntryViewCodec_encodeResponse() { + int fileClientMessageIndex = 111; + ClientMessage encoded = MapGetEntryViewCodec.encodeResponse(aSimpleEntryView, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeRequest() { + int fileClientMessageIndex = 112; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEvictCodec.RequestParameters parameters = MapEvictCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapEvictCodec_encodeResponse() { + int fileClientMessageIndex = 113; + ClientMessage encoded = MapEvictCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEvictAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeResponse() { + int fileClientMessageIndex = 115; + ClientMessage encoded = MapEvictAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 116; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapLoadAllCodec.RequestParameters parameters = MapLoadAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.replaceExistingValues)); + } + + @Test + public void test_MapLoadAllCodec_encodeResponse() { + int fileClientMessageIndex = 117; + ClientMessage encoded = MapLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapLoadGivenKeysCodec.RequestParameters parameters = MapLoadGivenKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(aBoolean, parameters.replaceExistingValues)); + } + + @Test + public void test_MapLoadGivenKeysCodec_encodeResponse() { + int fileClientMessageIndex = 119; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage encoded = MapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 122; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapGetAllCodec.RequestParameters parameters = MapGetAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_MapGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 123; + ClientMessage encoded = MapGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 124; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 125; + ClientMessage encoded = MapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 126; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 127; + ClientMessage encoded = MapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 128; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapKeySetWithPredicateCodec.RequestParameters parameters = MapKeySetWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapKeySetWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 129; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapValuesWithPredicateCodec.RequestParameters parameters = MapValuesWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapValuesWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEntriesWithPredicateCodec.RequestParameters parameters = MapEntriesWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapEntriesWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeRequest() { + int fileClientMessageIndex = 134; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddIndexCodec.RequestParameters parameters = MapAddIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anIndexConfig, parameters.indexConfig)); + } + + @Test + public void test_MapAddIndexCodec_encodeResponse() { + int fileClientMessageIndex = 135; + ClientMessage encoded = MapAddIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 137; + ClientMessage encoded = MapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 138; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 139; + ClientMessage encoded = MapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 140; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutAllCodec.RequestParameters parameters = MapPutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + assertTrue(parameters.isTriggerMapLoaderExists); + assertTrue(isEqual(aBoolean, parameters.triggerMapLoader)); + } + + @Test + public void test_MapPutAllCodec_encodeResponse() { + int fileClientMessageIndex = 141; + ClientMessage encoded = MapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeRequest() { + int fileClientMessageIndex = 142; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapClearCodec_encodeResponse() { + int fileClientMessageIndex = 143; + ClientMessage encoded = MapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeRequest() { + int fileClientMessageIndex = 144; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteOnKeyCodec.RequestParameters parameters = MapExecuteOnKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapExecuteOnKeyCodec_encodeResponse() { + int fileClientMessageIndex = 145; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 146; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSubmitToKeyCodec.RequestParameters parameters = MapSubmitToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MapSubmitToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 147; + ClientMessage encoded = MapSubmitToKeyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 148; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteOnAllKeysCodec.RequestParameters parameters = MapExecuteOnAllKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_encodeResponse() { + int fileClientMessageIndex = 149; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 150; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteWithPredicateCodec.RequestParameters parameters = MapExecuteWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapExecuteWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 151; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeRequest() { + int fileClientMessageIndex = 152; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapExecuteOnKeysCodec.RequestParameters parameters = MapExecuteOnKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aListOfData, parameters.keys)); + } + + @Test + public void test_MapExecuteOnKeysCodec_encodeResponse() { + int fileClientMessageIndex = 153; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 154; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapForceUnlockCodec.RequestParameters parameters = MapForceUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MapForceUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 155; + ClientMessage encoded = MapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 156; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapKeySetWithPagingPredicateCodec.RequestParameters parameters = MapKeySetWithPagingPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aPagingPredicateHolder, parameters.predicate)); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 157; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 158; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapValuesWithPagingPredicateCodec.RequestParameters parameters = MapValuesWithPagingPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aPagingPredicateHolder, parameters.predicate)); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 159; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 160; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEntriesWithPagingPredicateCodec.RequestParameters parameters = MapEntriesWithPagingPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aPagingPredicateHolder, parameters.predicate)); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 161; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeResponse(aListOfDataToData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeRequest() { + int fileClientMessageIndex = 162; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchKeysCodec.RequestParameters parameters = MapFetchKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_MapFetchKeysCodec_encodeResponse() { + int fileClientMessageIndex = 163; + ClientMessage encoded = MapFetchKeysCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 164; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchEntriesCodec.RequestParameters parameters = MapFetchEntriesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_MapFetchEntriesCodec_encodeResponse() { + int fileClientMessageIndex = 165; + ClientMessage encoded = MapFetchEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeRequest() { + int fileClientMessageIndex = 166; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAggregateCodec.RequestParameters parameters = MapAggregateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.aggregator)); + } + + @Test + public void test_MapAggregateCodec_encodeResponse() { + int fileClientMessageIndex = 167; + ClientMessage encoded = MapAggregateCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 168; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAggregateWithPredicateCodec.RequestParameters parameters = MapAggregateWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.aggregator)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapAggregateWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 169; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeRequest() { + int fileClientMessageIndex = 170; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapProjectCodec.RequestParameters parameters = MapProjectCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.projection)); + } + + @Test + public void test_MapProjectCodec_encodeResponse() { + int fileClientMessageIndex = 171; + ClientMessage encoded = MapProjectCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 172; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapProjectWithPredicateCodec.RequestParameters parameters = MapProjectWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.projection)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapProjectWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 173; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 174; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aListOfStrings, parameters.names)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 175; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 176; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapRemoveAllCodec.RequestParameters parameters = MapRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 177; + ClientMessage encoded = MapRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 178; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodec.RequestParameters parameters = MapAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.listenerFlags)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 179; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidationEvent() { + int fileClientMessageIndex = 180; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapInvalidationEvent(aData, aUUID, aUUID, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 181; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapBatchInvalidationEvent(aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchWithQueryCodec_decodeRequest() { + int fileClientMessageIndex = 182; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapFetchWithQueryCodec.RequestParameters parameters = MapFetchWithQueryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + assertTrue(isEqual(aData, parameters.projection)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_MapFetchWithQueryCodec_encodeResponse() { + int fileClientMessageIndex = 183; + ClientMessage encoded = MapFetchWithQueryCodec.encodeResponse(aListOfData, aListOfIntegerToInteger); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 184; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 185; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 186; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapEventJournalReadCodec.RequestParameters parameters = MapEventJournalReadCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.startSequence)); + assertTrue(isEqual(anInt, parameters.minSize)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aData, parameters.projection)); + } + + @Test + public void test_MapEventJournalReadCodec_encodeResponse() { + int fileClientMessageIndex = 187; + ClientMessage encoded = MapEventJournalReadCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeRequest() { + int fileClientMessageIndex = 188; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSetTtlCodec.RequestParameters parameters = MapSetTtlCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_MapSetTtlCodec_encodeResponse() { + int fileClientMessageIndex = 189; + ClientMessage encoded = MapSetTtlCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 190; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutWithMaxIdleCodec.RequestParameters parameters = MapPutWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapPutWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 191; + ClientMessage encoded = MapPutWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 192; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutTransientWithMaxIdleCodec.RequestParameters parameters = MapPutTransientWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 193; + ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 194; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutIfAbsentWithMaxIdleCodec.RequestParameters parameters = MapPutIfAbsentWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 195; + ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 196; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapSetWithMaxIdleCodec.RequestParameters parameters = MapSetWithMaxIdleCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.maxIdle)); + } + + @Test + public void test_MapSetWithMaxIdleCodec_encodeResponse() { + int fileClientMessageIndex = 197; + ClientMessage encoded = MapSetWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceAllCodec_decodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapReplaceAllCodec.RequestParameters parameters = MapReplaceAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + } + + @Test + public void test_MapReplaceAllCodec_encodeResponse() { + int fileClientMessageIndex = 199; + ClientMessage encoded = MapReplaceAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllWithMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapPutAllWithMetadataCodec.RequestParameters parameters = MapPutAllWithMetadataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfSimpleEntryViews, parameters.entries)); + } + + @Test + public void test_MapPutAllWithMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 201; + ClientMessage encoded = MapPutAllWithMetadataCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapPutCodec.RequestParameters parameters = MultiMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage encoded = MultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 204; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapGetCodec.RequestParameters parameters = MultiMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 205; + ClientMessage encoded = MultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 206; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapRemoveCodec.RequestParameters parameters = MultiMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 207; + ClientMessage encoded = MultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 208; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 209; + ClientMessage encoded = MultiMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage encoded = MultiMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 213; + ClientMessage encoded = MultiMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 214; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapContainsKeyCodec.RequestParameters parameters = MultiMapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 215; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 216; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapContainsValueCodec.RequestParameters parameters = MultiMapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_MultiMapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 217; + ClientMessage encoded = MultiMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeRequest() { + int fileClientMessageIndex = 218; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapContainsEntryCodec.RequestParameters parameters = MultiMapContainsEntryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapContainsEntryCodec_encodeResponse() { + int fileClientMessageIndex = 219; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 220; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 221; + ClientMessage encoded = MultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 222; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 223; + ClientMessage encoded = MultiMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 224; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapValueCountCodec.RequestParameters parameters = MultiMapValueCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapValueCountCodec_encodeResponse() { + int fileClientMessageIndex = 225; + ClientMessage encoded = MultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 226; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerToKeyCodec.RequestParameters parameters = MultiMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 227; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 228; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 229; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerCodec.RequestParameters parameters = MultiMapAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 230; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 231; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 232; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapRemoveEntryListenerCodec.RequestParameters parameters = MultiMapRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 233; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapLockCodec_decodeRequest() { + int fileClientMessageIndex = 234; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapLockCodec.RequestParameters parameters = MultiMapLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.ttl)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapLockCodec_encodeResponse() { + int fileClientMessageIndex = 235; + ClientMessage encoded = MultiMapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 236; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapTryLockCodec.RequestParameters parameters = MultiMapTryLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.lease)); + assertTrue(isEqual(aLong, parameters.timeout)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapTryLockCodec_encodeResponse() { + int fileClientMessageIndex = 237; + ClientMessage encoded = MultiMapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 238; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapIsLockedCodec.RequestParameters parameters = MultiMapIsLockedCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_MultiMapIsLockedCodec_encodeResponse() { + int fileClientMessageIndex = 239; + ClientMessage encoded = MultiMapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 240; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapUnlockCodec.RequestParameters parameters = MultiMapUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 241; + ClientMessage encoded = MultiMapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 242; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapForceUnlockCodec.RequestParameters parameters = MultiMapForceUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.referenceId)); + } + + @Test + public void test_MultiMapForceUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 243; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapRemoveEntryCodec.RequestParameters parameters = MultiMapRemoveEntryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapRemoveEntryCodec_encodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 246; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapDeleteCodec.RequestParameters parameters = MultiMapDeleteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_MultiMapDeleteCodec_encodeResponse() { + int fileClientMessageIndex = 247; + ClientMessage encoded = MultiMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 248; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapPutAllCodec.RequestParameters parameters = MultiMapPutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToListOfData, parameters.entries)); + } + + @Test + public void test_MultiMapPutAllCodec_encodeResponse() { + int fileClientMessageIndex = 249; + ClientMessage encoded = MultiMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueOfferCodec.RequestParameters parameters = QueueOfferCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + } + + @Test + public void test_QueueOfferCodec_encodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage encoded = QueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueuePutCodec.RequestParameters parameters = QueuePutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_QueuePutCodec_encodeResponse() { + int fileClientMessageIndex = 253; + ClientMessage encoded = QueuePutCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueSizeCodec_encodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage encoded = QueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueRemoveCodec.RequestParameters parameters = QueueRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_QueueRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage encoded = QueueRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 258; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueuePollCodec.RequestParameters parameters = QueuePollCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + } + + @Test + public void test_QueuePollCodec_encodeResponse() { + int fileClientMessageIndex = 259; + ClientMessage encoded = QueuePollCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 260; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueTakeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeResponse() { + int fileClientMessageIndex = 261; + ClientMessage encoded = QueueTakeCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 262; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueuePeekCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeResponse() { + int fileClientMessageIndex = 263; + ClientMessage encoded = QueuePeekCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 264; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 265; + ClientMessage encoded = QueueIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeRequest() { + int fileClientMessageIndex = 266; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueDrainToCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeResponse() { + int fileClientMessageIndex = 267; + ClientMessage encoded = QueueDrainToCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueDrainToMaxSizeCodec.RequestParameters parameters = QueueDrainToMaxSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.maxSize)); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_encodeResponse() { + int fileClientMessageIndex = 269; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeRequest() { + int fileClientMessageIndex = 270; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueContainsCodec.RequestParameters parameters = QueueContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_QueueContainsCodec_encodeResponse() { + int fileClientMessageIndex = 271; + ClientMessage encoded = QueueContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 272; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueContainsAllCodec.RequestParameters parameters = QueueContainsAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueContainsAllCodec_encodeResponse() { + int fileClientMessageIndex = 273; + ClientMessage encoded = QueueContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 274; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueCompareAndRemoveAllCodec.RequestParameters parameters = QueueCompareAndRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 275; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 276; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueCompareAndRetainAllCodec.RequestParameters parameters = QueueCompareAndRetainAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_encodeResponse() { + int fileClientMessageIndex = 277; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeRequest() { + int fileClientMessageIndex = 278; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeResponse() { + int fileClientMessageIndex = 279; + ClientMessage encoded = QueueClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 280; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddAllCodec.RequestParameters parameters = QueueAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.dataList)); + } + + @Test + public void test_QueueAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 281; + ClientMessage encoded = QueueAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 282; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddListenerCodec.RequestParameters parameters = QueueAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_QueueAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 283; + ClientMessage encoded = QueueAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 284; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = QueueAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 285; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueRemoveListenerCodec.RequestParameters parameters = QueueRemoveListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_QueueRemoveListenerCodec_encodeResponse() { + int fileClientMessageIndex = 286; + ClientMessage encoded = QueueRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 287; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 288; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 289; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 290; + ClientMessage encoded = QueueIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeRequest() { + int fileClientMessageIndex = 291; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicPublishCodec.RequestParameters parameters = TopicPublishCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.message)); + } + + @Test + public void test_TopicPublishCodec_encodeResponse() { + int fileClientMessageIndex = 292; + ClientMessage encoded = TopicPublishCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 293; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicAddMessageListenerCodec.RequestParameters parameters = TopicAddMessageListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeResponse() { + int fileClientMessageIndex = 294; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { + int fileClientMessageIndex = 295; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = TopicAddMessageListenerCodec.encodeTopicEvent(aData, aLong, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 296; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicRemoveMessageListenerCodec.RequestParameters parameters = TopicRemoveMessageListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_encodeResponse() { + int fileClientMessageIndex = 297; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeRequest() { + int fileClientMessageIndex = 298; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicPublishAllCodec.RequestParameters parameters = TopicPublishAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.messages)); + } + + @Test + public void test_TopicPublishAllCodec_encodeResponse() { + int fileClientMessageIndex = 299; + ClientMessage encoded = TopicPublishAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 300; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListSizeCodec_encodeResponse() { + int fileClientMessageIndex = 301; + ClientMessage encoded = ListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeRequest() { + int fileClientMessageIndex = 302; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListContainsCodec.RequestParameters parameters = ListContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListContainsCodec_encodeResponse() { + int fileClientMessageIndex = 303; + ClientMessage encoded = ListContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 304; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListContainsAllCodec.RequestParameters parameters = ListContainsAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_ListContainsAllCodec_encodeResponse() { + int fileClientMessageIndex = 305; + ClientMessage encoded = ListContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddCodec.RequestParameters parameters = ListAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListAddCodec_encodeResponse() { + int fileClientMessageIndex = 307; + ClientMessage encoded = ListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListRemoveCodec.RequestParameters parameters = ListRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage encoded = ListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 310; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddAllCodec.RequestParameters parameters = ListAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + } + + @Test + public void test_ListAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 311; + ClientMessage encoded = ListAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 312; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListCompareAndRemoveAllCodec.RequestParameters parameters = ListCompareAndRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 313; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 314; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListCompareAndRetainAllCodec.RequestParameters parameters = ListCompareAndRetainAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_ListCompareAndRetainAllCodec_encodeResponse() { + int fileClientMessageIndex = 315; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeRequest() { + int fileClientMessageIndex = 316; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeResponse() { + int fileClientMessageIndex = 317; + ClientMessage encoded = ListClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 318; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 319; + ClientMessage encoded = ListGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 320; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddListenerCodec.RequestParameters parameters = ListAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ListAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 321; + ClientMessage encoded = ListAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 322; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ListAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 323; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListRemoveListenerCodec.RequestParameters parameters = ListRemoveListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_ListRemoveListenerCodec_encodeResponse() { + int fileClientMessageIndex = 324; + ClientMessage encoded = ListRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 325; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 326; + ClientMessage encoded = ListIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 327; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddAllWithIndexCodec.RequestParameters parameters = ListAddAllWithIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + } + + @Test + public void test_ListAddAllWithIndexCodec_encodeResponse() { + int fileClientMessageIndex = 328; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeRequest() { + int fileClientMessageIndex = 329; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListGetCodec.RequestParameters parameters = ListGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + } + + @Test + public void test_ListGetCodec_encodeResponse() { + int fileClientMessageIndex = 330; + ClientMessage encoded = ListGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeRequest() { + int fileClientMessageIndex = 331; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListSetCodec.RequestParameters parameters = ListSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListSetCodec_encodeResponse() { + int fileClientMessageIndex = 332; + ClientMessage encoded = ListSetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddWithIndexCodec.RequestParameters parameters = ListAddWithIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListAddWithIndexCodec_encodeResponse() { + int fileClientMessageIndex = 334; + ClientMessage encoded = ListAddWithIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 335; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListRemoveWithIndexCodec.RequestParameters parameters = ListRemoveWithIndexCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + } + + @Test + public void test_ListRemoveWithIndexCodec_encodeResponse() { + int fileClientMessageIndex = 336; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListLastIndexOfCodec.RequestParameters parameters = ListLastIndexOfCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListLastIndexOfCodec_encodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage encoded = ListLastIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 339; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListIndexOfCodec.RequestParameters parameters = ListIndexOfCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ListIndexOfCodec_encodeResponse() { + int fileClientMessageIndex = 340; + ClientMessage encoded = ListIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeRequest() { + int fileClientMessageIndex = 341; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListSubCodec.RequestParameters parameters = ListSubCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.from)); + assertTrue(isEqual(anInt, parameters.to)); + } + + @Test + public void test_ListSubCodec_encodeResponse() { + int fileClientMessageIndex = 342; + ClientMessage encoded = ListSubCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 343; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 344; + ClientMessage encoded = ListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 345; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListListIteratorCodec.RequestParameters parameters = ListListIteratorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.index)); + } + + @Test + public void test_ListListIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 346; + ClientMessage encoded = ListListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 347; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeResponse() { + int fileClientMessageIndex = 348; + ClientMessage encoded = SetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeRequest() { + int fileClientMessageIndex = 349; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetContainsCodec.RequestParameters parameters = SetContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_SetContainsCodec_encodeResponse() { + int fileClientMessageIndex = 350; + ClientMessage encoded = SetContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 351; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetContainsAllCodec.RequestParameters parameters = SetContainsAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.items)); + } + + @Test + public void test_SetContainsAllCodec_encodeResponse() { + int fileClientMessageIndex = 352; + ClientMessage encoded = SetContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddCodec.RequestParameters parameters = SetAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_SetAddCodec_encodeResponse() { + int fileClientMessageIndex = 354; + ClientMessage encoded = SetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetRemoveCodec.RequestParameters parameters = SetRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_SetRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage encoded = SetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 357; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddAllCodec.RequestParameters parameters = SetAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + } + + @Test + public void test_SetAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 358; + ClientMessage encoded = SetAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 359; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetCompareAndRemoveAllCodec.RequestParameters parameters = SetCompareAndRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 360; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 361; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetCompareAndRetainAllCodec.RequestParameters parameters = SetCompareAndRetainAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.values)); + } + + @Test + public void test_SetCompareAndRetainAllCodec_encodeResponse() { + int fileClientMessageIndex = 362; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeRequest() { + int fileClientMessageIndex = 363; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeResponse() { + int fileClientMessageIndex = 364; + ClientMessage encoded = SetClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 365; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 366; + ClientMessage encoded = SetGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 367; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddListenerCodec.RequestParameters parameters = SetAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_SetAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 368; + ClientMessage encoded = SetAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 369; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = SetAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 370; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetRemoveListenerCodec.RequestParameters parameters = SetRemoveListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_SetRemoveListenerCodec_encodeResponse() { + int fileClientMessageIndex = 371; + ClientMessage encoded = SetRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 372; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 373; + ClientMessage encoded = SetIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockLockCodec_decodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockLockCodec.RequestParameters parameters = FencedLockLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + } + + @Test + public void test_FencedLockLockCodec_encodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage encoded = FencedLockLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 376; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockTryLockCodec.RequestParameters parameters = FencedLockTryLockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(aLong, parameters.timeoutMs)); + } + + @Test + public void test_FencedLockTryLockCodec_encodeResponse() { + int fileClientMessageIndex = 377; + ClientMessage encoded = FencedLockTryLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 378; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockUnlockCodec.RequestParameters parameters = FencedLockUnlockCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + } + + @Test + public void test_FencedLockUnlockCodec_encodeResponse() { + int fileClientMessageIndex = 379; + ClientMessage encoded = FencedLockUnlockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { + int fileClientMessageIndex = 380; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FencedLockGetLockOwnershipCodec.RequestParameters parameters = FencedLockGetLockOwnershipCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_encodeResponse() { + int fileClientMessageIndex = 381; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeResponse(aLong, anInt, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 382; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 383; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 384; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 385; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 386; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceCancelOnPartitionCodec.RequestParameters parameters = ExecutorServiceCancelOnPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aBoolean, parameters.interrupt)); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 387; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { + int fileClientMessageIndex = 388; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceCancelOnMemberCodec.RequestParameters parameters = ExecutorServiceCancelOnMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aUUID, parameters.memberUUID)); + assertTrue(isEqual(aBoolean, parameters.interrupt)); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_encodeResponse() { + int fileClientMessageIndex = 389; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 390; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceSubmitToPartitionCodec.RequestParameters parameters = ExecutorServiceSubmitToPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aData, parameters.callable)); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 391; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 392; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExecutorServiceSubmitToMemberCodec.RequestParameters parameters = ExecutorServiceSubmitToMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aData, parameters.callable)); + assertTrue(isEqual(aUUID, parameters.memberUUID)); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_encodeResponse() { + int fileClientMessageIndex = 393; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeRequest() { + int fileClientMessageIndex = 394; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongApplyCodec.RequestParameters parameters = AtomicLongApplyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + } + + @Test + public void test_AtomicLongApplyCodec_encodeResponse() { + int fileClientMessageIndex = 395; + ClientMessage encoded = AtomicLongApplyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeRequest() { + int fileClientMessageIndex = 396; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongAlterCodec.RequestParameters parameters = AtomicLongAlterCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + assertTrue(isEqual(anInt, parameters.returnValueType)); + } + + @Test + public void test_AtomicLongAlterCodec_encodeResponse() { + int fileClientMessageIndex = 397; + ClientMessage encoded = AtomicLongAlterCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeRequest() { + int fileClientMessageIndex = 398; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongAddAndGetCodec.RequestParameters parameters = AtomicLongAddAndGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.delta)); + } + + @Test + public void test_AtomicLongAddAndGetCodec_encodeResponse() { + int fileClientMessageIndex = 399; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 400; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongCompareAndSetCodec.RequestParameters parameters = AtomicLongCompareAndSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.expected)); + assertTrue(isEqual(aLong, parameters.updated)); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_encodeResponse() { + int fileClientMessageIndex = 401; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeRequest() { + int fileClientMessageIndex = 402; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongGetCodec.RequestParameters parameters = AtomicLongGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_AtomicLongGetCodec_encodeResponse() { + int fileClientMessageIndex = 403; + ClientMessage encoded = AtomicLongGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeRequest() { + int fileClientMessageIndex = 404; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongGetAndAddCodec.RequestParameters parameters = AtomicLongGetAndAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.delta)); + } + + @Test + public void test_AtomicLongGetAndAddCodec_encodeResponse() { + int fileClientMessageIndex = 405; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 406; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicLongGetAndSetCodec.RequestParameters parameters = AtomicLongGetAndSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.newValue)); + } + + @Test + public void test_AtomicLongGetAndSetCodec_encodeResponse() { + int fileClientMessageIndex = 407; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefApplyCodec_decodeRequest() { + int fileClientMessageIndex = 408; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefApplyCodec.RequestParameters parameters = AtomicRefApplyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.function)); + assertTrue(isEqual(anInt, parameters.returnValueType)); + assertTrue(isEqual(aBoolean, parameters.alter)); + } + + @Test + public void test_AtomicRefApplyCodec_encodeResponse() { + int fileClientMessageIndex = 409; + ClientMessage encoded = AtomicRefApplyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 410; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefCompareAndSetCodec.RequestParameters parameters = AtomicRefCompareAndSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.oldValue)); + assertTrue(isEqual(aData, parameters.newValue)); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_encodeResponse() { + int fileClientMessageIndex = 411; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeRequest() { + int fileClientMessageIndex = 412; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefContainsCodec.RequestParameters parameters = AtomicRefContainsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_AtomicRefContainsCodec_encodeResponse() { + int fileClientMessageIndex = 413; + ClientMessage encoded = AtomicRefContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeRequest() { + int fileClientMessageIndex = 414; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefGetCodec.RequestParameters parameters = AtomicRefGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_AtomicRefGetCodec_encodeResponse() { + int fileClientMessageIndex = 415; + ClientMessage encoded = AtomicRefGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeRequest() { + int fileClientMessageIndex = 416; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + AtomicRefSetCodec.RequestParameters parameters = AtomicRefSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.newValue)); + assertTrue(isEqual(aBoolean, parameters.returnOldValue)); + } + + @Test + public void test_AtomicRefSetCodec_encodeResponse() { + int fileClientMessageIndex = 417; + ClientMessage encoded = AtomicRefSetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeRequest() { + int fileClientMessageIndex = 418; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchTrySetCountCodec.RequestParameters parameters = CountDownLatchTrySetCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.count)); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_encodeResponse() { + int fileClientMessageIndex = 419; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeRequest() { + int fileClientMessageIndex = 420; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchAwaitCodec.RequestParameters parameters = CountDownLatchAwaitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(aLong, parameters.timeoutMs)); + } + + @Test + public void test_CountDownLatchAwaitCodec_encodeResponse() { + int fileClientMessageIndex = 421; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeRequest() { + int fileClientMessageIndex = 422; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchCountDownCodec.RequestParameters parameters = CountDownLatchCountDownCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.expectedRound)); + } + + @Test + public void test_CountDownLatchCountDownCodec_encodeResponse() { + int fileClientMessageIndex = 423; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeRequest() { + int fileClientMessageIndex = 424; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchGetCountCodec.RequestParameters parameters = CountDownLatchGetCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_CountDownLatchGetCountCodec_encodeResponse() { + int fileClientMessageIndex = 425; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeRequest() { + int fileClientMessageIndex = 426; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CountDownLatchGetRoundCodec.RequestParameters parameters = CountDownLatchGetRoundCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_CountDownLatchGetRoundCodec_encodeResponse() { + int fileClientMessageIndex = 427; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeRequest() { + int fileClientMessageIndex = 428; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreInitCodec.RequestParameters parameters = SemaphoreInitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.permits)); + } + + @Test + public void test_SemaphoreInitCodec_encodeResponse() { + int fileClientMessageIndex = 429; + ClientMessage encoded = SemaphoreInitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAcquireCodec_decodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreAcquireCodec.RequestParameters parameters = SemaphoreAcquireCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.permits)); + assertTrue(isEqual(aLong, parameters.timeoutMs)); + } + + @Test + public void test_SemaphoreAcquireCodec_encodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage encoded = SemaphoreAcquireCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreReleaseCodec_decodeRequest() { + int fileClientMessageIndex = 432; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreReleaseCodec.RequestParameters parameters = SemaphoreReleaseCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.permits)); + } + + @Test + public void test_SemaphoreReleaseCodec_encodeResponse() { + int fileClientMessageIndex = 433; + ClientMessage encoded = SemaphoreReleaseCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreDrainCodec_decodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreDrainCodec.RequestParameters parameters = SemaphoreDrainCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + } + + @Test + public void test_SemaphoreDrainCodec_encodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage encoded = SemaphoreDrainCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreChangeCodec_decodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreChangeCodec.RequestParameters parameters = SemaphoreChangeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sessionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aUUID, parameters.invocationUid)); + assertTrue(isEqual(anInt, parameters.permits)); + } + + @Test + public void test_SemaphoreChangeCodec_encodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage encoded = SemaphoreChangeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { + int fileClientMessageIndex = 438; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SemaphoreAvailablePermitsCodec.RequestParameters parameters = SemaphoreAvailablePermitsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.name)); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_encodeResponse() { + int fileClientMessageIndex = 439; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeRequest() { + int fileClientMessageIndex = 440; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SemaphoreGetSemaphoreTypeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { + int fileClientMessageIndex = 441; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 442; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapPutCodec.RequestParameters parameters = ReplicatedMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_ReplicatedMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 443; + ClientMessage encoded = ReplicatedMapPutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 444; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 445; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 446; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 447; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapContainsKeyCodec.RequestParameters parameters = ReplicatedMapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 449; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 450; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapContainsValueCodec.RequestParameters parameters = ReplicatedMapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 451; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 452; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapGetCodec.RequestParameters parameters = ReplicatedMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_ReplicatedMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 453; + ClientMessage encoded = ReplicatedMapGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 454; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapRemoveCodec.RequestParameters parameters = ReplicatedMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_ReplicatedMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 455; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 456; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapPutAllCodec.RequestParameters parameters = ReplicatedMapPutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + } + + @Test + public void test_ReplicatedMapPutAllCodec_encodeResponse() { + int fileClientMessageIndex = 457; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 458; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 459; + ClientMessage encoded = ReplicatedMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 460; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 461; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 462; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 463; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 464; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 465; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 468; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 469; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 470; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 471; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 472; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapRemoveEntryListenerCodec.RequestParameters parameters = ReplicatedMapRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 473; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 474; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 475; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 476; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 477; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 478; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 479; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 480; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddNearCacheEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddNearCacheEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.includeValue)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 481; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 482; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 483; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapContainsKeyCodec.RequestParameters parameters = TransactionalMapContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 484; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 485; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapGetCodec.RequestParameters parameters = TransactionalMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 486; + ClientMessage encoded = TransactionalMapGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { + int fileClientMessageIndex = 487; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapGetForUpdateCodec.RequestParameters parameters = TransactionalMapGetForUpdateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_encodeResponse() { + int fileClientMessageIndex = 488; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 489; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapSizeCodec.RequestParameters parameters = TransactionalMapSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 490; + ClientMessage encoded = TransactionalMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 491; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapIsEmptyCodec.RequestParameters parameters = TransactionalMapIsEmptyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 492; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 493; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapPutCodec.RequestParameters parameters = TransactionalMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aLong, parameters.ttl)); + } + + @Test + public void test_TransactionalMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 494; + ClientMessage encoded = TransactionalMapPutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSetCodec_decodeRequest() { + int fileClientMessageIndex = 495; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapSetCodec.RequestParameters parameters = TransactionalMapSetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapSetCodec_encodeResponse() { + int fileClientMessageIndex = 496; + ClientMessage encoded = TransactionalMapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 497; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapPutIfAbsentCodec.RequestParameters parameters = TransactionalMapPutIfAbsentCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_encodeResponse() { + int fileClientMessageIndex = 498; + ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 499; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapReplaceCodec.RequestParameters parameters = TransactionalMapReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 500; + ClientMessage encoded = TransactionalMapReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 501; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapReplaceIfSameCodec.RequestParameters parameters = TransactionalMapReplaceIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.oldValue)); + assertTrue(isEqual(aData, parameters.newValue)); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 502; + ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 503; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapRemoveCodec.RequestParameters parameters = TransactionalMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 504; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 505; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapDeleteCodec.RequestParameters parameters = TransactionalMapDeleteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMapDeleteCodec_encodeResponse() { + int fileClientMessageIndex = 506; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 507; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapRemoveIfSameCodec.RequestParameters parameters = TransactionalMapRemoveIfSameCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_encodeResponse() { + int fileClientMessageIndex = 508; + ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 509; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapKeySetCodec.RequestParameters parameters = TransactionalMapKeySetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 510; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 511; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapKeySetWithPredicateCodec.RequestParameters parameters = TransactionalMapKeySetWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 512; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 513; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapValuesCodec.RequestParameters parameters = TransactionalMapValuesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 514; + ClientMessage encoded = TransactionalMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 515; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapValuesWithPredicateCodec.RequestParameters parameters = TransactionalMapValuesWithPredicateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.predicate)); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_encodeResponse() { + int fileClientMessageIndex = 516; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 517; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMapContainsValueCodec.RequestParameters parameters = TransactionalMapContainsValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMapContainsValueCodec_encodeResponse() { + int fileClientMessageIndex = 518; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 519; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapPutCodec.RequestParameters parameters = TransactionalMultiMapPutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMultiMapPutCodec_encodeResponse() { + int fileClientMessageIndex = 520; + ClientMessage encoded = TransactionalMultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 521; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapGetCodec.RequestParameters parameters = TransactionalMultiMapGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMultiMapGetCodec_encodeResponse() { + int fileClientMessageIndex = 522; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 523; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapRemoveCodec.RequestParameters parameters = TransactionalMultiMapRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 524; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 525; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapRemoveEntryCodec.RequestParameters parameters = TransactionalMultiMapRemoveEntryCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_encodeResponse() { + int fileClientMessageIndex = 526; + ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 527; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapValueCountCodec.RequestParameters parameters = TransactionalMultiMapValueCountCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_encodeResponse() { + int fileClientMessageIndex = 528; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 529; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalMultiMapSizeCodec.RequestParameters parameters = TransactionalMultiMapSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 530; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeRequest() { + int fileClientMessageIndex = 531; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalSetAddCodec.RequestParameters parameters = TransactionalSetAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalSetAddCodec_encodeResponse() { + int fileClientMessageIndex = 532; + ClientMessage encoded = TransactionalSetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 533; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalSetRemoveCodec.RequestParameters parameters = TransactionalSetRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalSetRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 534; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 535; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalSetSizeCodec.RequestParameters parameters = TransactionalSetSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalSetSizeCodec_encodeResponse() { + int fileClientMessageIndex = 536; + ClientMessage encoded = TransactionalSetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeRequest() { + int fileClientMessageIndex = 537; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalListAddCodec.RequestParameters parameters = TransactionalListAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalListAddCodec_encodeResponse() { + int fileClientMessageIndex = 538; + ClientMessage encoded = TransactionalListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 539; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalListRemoveCodec.RequestParameters parameters = TransactionalListRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + } + + @Test + public void test_TransactionalListRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 540; + ClientMessage encoded = TransactionalListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 541; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalListSizeCodec.RequestParameters parameters = TransactionalListSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalListSizeCodec_encodeResponse() { + int fileClientMessageIndex = 542; + ClientMessage encoded = TransactionalListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 543; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueueOfferCodec.RequestParameters parameters = TransactionalQueueOfferCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aData, parameters.item)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_TransactionalQueueOfferCodec_encodeResponse() { + int fileClientMessageIndex = 544; + ClientMessage encoded = TransactionalQueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 545; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueueTakeCodec.RequestParameters parameters = TransactionalQueueTakeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalQueueTakeCodec_encodeResponse() { + int fileClientMessageIndex = 546; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 547; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueuePollCodec.RequestParameters parameters = TransactionalQueuePollCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_TransactionalQueuePollCodec_encodeResponse() { + int fileClientMessageIndex = 548; + ClientMessage encoded = TransactionalQueuePollCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 549; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueuePeekCodec.RequestParameters parameters = TransactionalQueuePeekCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_TransactionalQueuePeekCodec_encodeResponse() { + int fileClientMessageIndex = 550; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 551; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionalQueueSizeCodec.RequestParameters parameters = TransactionalQueueSizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.txnId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionalQueueSizeCodec_encodeResponse() { + int fileClientMessageIndex = 552; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 553; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddEntryListenerCodec.RequestParameters parameters = CacheAddEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 554; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { + int fileClientMessageIndex = 555; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddEntryListenerCodec.encodeCacheEvent(anInt, aListOfCacheEventData, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheClearCodec_encodeResponse() { + int fileClientMessageIndex = 557; + ClientMessage encoded = CacheClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 558; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveAllKeysCodec.RequestParameters parameters = CacheRemoveAllKeysCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheRemoveAllKeysCodec_encodeResponse() { + int fileClientMessageIndex = 559; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 560; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveAllCodec.RequestParameters parameters = CacheRemoveAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheRemoveAllCodec_encodeResponse() { + int fileClientMessageIndex = 561; + ClientMessage encoded = CacheRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 562; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheContainsKeyCodec.RequestParameters parameters = CacheContainsKeyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + } + + @Test + public void test_CacheContainsKeyCodec_encodeResponse() { + int fileClientMessageIndex = 563; + ClientMessage encoded = CacheContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeRequest() { + int fileClientMessageIndex = 564; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheCreateConfigCodec.RequestParameters parameters = CacheCreateConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aCacheConfigHolder, parameters.cacheConfig)); + assertTrue(isEqual(aBoolean, parameters.createAlsoOnOthers)); + } + + @Test + public void test_CacheCreateConfigCodec_encodeResponse() { + int fileClientMessageIndex = 565; + ClientMessage encoded = CacheCreateConfigCodec.encodeResponse(aCacheConfigHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeRequest() { + int fileClientMessageIndex = 566; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheDestroyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeResponse() { + int fileClientMessageIndex = 567; + ClientMessage encoded = CacheDestroyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEntryProcessorCodec_decodeRequest() { + int fileClientMessageIndex = 568; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEntryProcessorCodec.RequestParameters parameters = CacheEntryProcessorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.entryProcessor)); + assertTrue(isEqual(aListOfData, parameters.arguments)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheEntryProcessorCodec_encodeResponse() { + int fileClientMessageIndex = 569; + ClientMessage encoded = CacheEntryProcessorCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 570; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetAllCodec.RequestParameters parameters = CacheGetAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + } + + @Test + public void test_CacheGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 571; + ClientMessage encoded = CacheGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 572; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetAndRemoveCodec.RequestParameters parameters = CacheGetAndRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheGetAndRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 573; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 574; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetAndReplaceCodec.RequestParameters parameters = CacheGetAndReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheGetAndReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 575; + ClientMessage encoded = CacheGetAndReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 576; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetConfigCodec.RequestParameters parameters = CacheGetConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.simpleName)); + } + + @Test + public void test_CacheGetConfigCodec_encodeResponse() { + int fileClientMessageIndex = 577; + ClientMessage encoded = CacheGetConfigCodec.encodeResponse(aCacheConfigHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeRequest() { + int fileClientMessageIndex = 578; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheGetCodec.RequestParameters parameters = CacheGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + } + + @Test + public void test_CacheGetCodec_encodeResponse() { + int fileClientMessageIndex = 579; + ClientMessage encoded = CacheGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeRequest() { + int fileClientMessageIndex = 580; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateCodec.RequestParameters parameters = CacheIterateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_CacheIterateCodec_encodeResponse() { + int fileClientMessageIndex = 581; + ClientMessage encoded = CacheIterateCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeRequest() { + int fileClientMessageIndex = 582; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheListenerRegistrationCodec.RequestParameters parameters = CacheListenerRegistrationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.listenerConfig)); + assertTrue(isEqual(aBoolean, parameters.shouldRegister)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_CacheListenerRegistrationCodec_encodeResponse() { + int fileClientMessageIndex = 583; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 584; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheLoadAllCodec.RequestParameters parameters = CacheLoadAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(aBoolean, parameters.replaceExistingValues)); + } + + @Test + public void test_CacheLoadAllCodec_encodeResponse() { + int fileClientMessageIndex = 585; + ClientMessage encoded = CacheLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeRequest() { + int fileClientMessageIndex = 586; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheManagementConfigCodec.RequestParameters parameters = CacheManagementConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.isStat)); + assertTrue(isEqual(aBoolean, parameters.enabled)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_CacheManagementConfigCodec_encodeResponse() { + int fileClientMessageIndex = 587; + ClientMessage encoded = CacheManagementConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 588; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CachePutIfAbsentCodec.RequestParameters parameters = CachePutIfAbsentCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CachePutIfAbsentCodec_encodeResponse() { + int fileClientMessageIndex = 589; + ClientMessage encoded = CachePutIfAbsentCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutCodec_decodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CachePutCodec.RequestParameters parameters = CachePutCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.value)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + assertTrue(isEqual(aBoolean, parameters.get)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CachePutCodec_encodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage encoded = CachePutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 592; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveEntryListenerCodec.RequestParameters parameters = CacheRemoveEntryListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_encodeResponse() { + int fileClientMessageIndex = 593; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 594; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveInvalidationListenerCodec.RequestParameters parameters = CacheRemoveInvalidationListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 595; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 596; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemoveCodec.RequestParameters parameters = CacheRemoveCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.currentValue)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheRemoveCodec_encodeResponse() { + int fileClientMessageIndex = 597; + ClientMessage encoded = CacheRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 598; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheReplaceCodec.RequestParameters parameters = CacheReplaceCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.key)); + assertTrue(isEqual(aData, parameters.oldValue)); + assertTrue(isEqual(aData, parameters.newValue)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CacheReplaceCodec_encodeResponse() { + int fileClientMessageIndex = 599; + ClientMessage encoded = CacheReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeRequest() { + int fileClientMessageIndex = 600; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeResponse() { + int fileClientMessageIndex = 601; + ClientMessage encoded = CacheSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 602; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddPartitionLostListenerCodec.RequestParameters parameters = CacheAddPartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 603; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEvent() { + int fileClientMessageIndex = 604; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeCachePartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 605; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheRemovePartitionLostListenerCodec.RequestParameters parameters = CacheRemovePartitionLostListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_encodeResponse() { + int fileClientMessageIndex = 606; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeRequest() { + int fileClientMessageIndex = 607; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CachePutAllCodec.RequestParameters parameters = CachePutAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfDataToData, parameters.entries)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + assertTrue(isEqual(anInt, parameters.completionId)); + } + + @Test + public void test_CachePutAllCodec_encodeResponse() { + int fileClientMessageIndex = 608; + ClientMessage encoded = CachePutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 609; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheIterateEntriesCodec.RequestParameters parameters = CacheIterateEntriesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); + assertTrue(isEqual(anInt, parameters.batch)); + } + + @Test + public void test_CacheIterateEntriesCodec_encodeResponse() { + int fileClientMessageIndex = 610; + ClientMessage encoded = CacheIterateEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 611; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodec.RequestParameters parameters = CacheAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeResponse() { + int fileClientMessageIndex = 612; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidationEvent() { + int fileClientMessageIndex = 613; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheInvalidationEvent(aString, aData, aUUID, aUUID, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheBatchInvalidationEvent() { + int fileClientMessageIndex = 614; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheBatchInvalidationEvent(aString, aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 615; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = CacheFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aListOfStrings, parameters.names)); + assertTrue(isEqual(aUUID, parameters.uuid)); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 617; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 618; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 619; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheEventJournalReadCodec.RequestParameters parameters = CacheEventJournalReadCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.startSequence)); + assertTrue(isEqual(anInt, parameters.minSize)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(aData, parameters.projection)); + } + + @Test + public void test_CacheEventJournalReadCodec_encodeResponse() { + int fileClientMessageIndex = 620; + ClientMessage encoded = CacheEventJournalReadCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeRequest() { + int fileClientMessageIndex = 621; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheSetExpiryPolicyCodec.RequestParameters parameters = CacheSetExpiryPolicyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.keys)); + assertTrue(isEqual(aData, parameters.expiryPolicy)); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_encodeResponse() { + int fileClientMessageIndex = 622; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anXid, XATransactionClearRemoteCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeResponse() { + int fileClientMessageIndex = 624; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeRequest() { + int fileClientMessageIndex = 625; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeResponse() { + int fileClientMessageIndex = 626; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeResponse(aListOfXids); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeRequest() { + int fileClientMessageIndex = 627; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + XATransactionFinalizeCodec.RequestParameters parameters = XATransactionFinalizeCodec.decodeRequest(fromFile); + assertTrue(isEqual(anXid, parameters.xid)); + assertTrue(isEqual(aBoolean, parameters.isCommit)); + } + + @Test + public void test_XATransactionFinalizeCodec_encodeResponse() { + int fileClientMessageIndex = 628; + ClientMessage encoded = XATransactionFinalizeCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 629; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + XATransactionCommitCodec.RequestParameters parameters = XATransactionCommitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.transactionId)); + assertTrue(isEqual(aBoolean, parameters.onePhase)); + } + + @Test + public void test_XATransactionCommitCodec_encodeResponse() { + int fileClientMessageIndex = 630; + ClientMessage encoded = XATransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 631; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + XATransactionCreateCodec.RequestParameters parameters = XATransactionCreateCodec.decodeRequest(fromFile); + assertTrue(isEqual(anXid, parameters.xid)); + assertTrue(isEqual(aLong, parameters.timeout)); + } + + @Test + public void test_XATransactionCreateCodec_encodeResponse() { + int fileClientMessageIndex = 632; + ClientMessage encoded = XATransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeRequest() { + int fileClientMessageIndex = 633; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionPrepareCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeResponse() { + int fileClientMessageIndex = 634; + ClientMessage encoded = XATransactionPrepareCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 635; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionRollbackCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionRollbackCodec_encodeResponse() { + int fileClientMessageIndex = 636; + ClientMessage encoded = XATransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 637; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionCommitCodec.RequestParameters parameters = TransactionCommitCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.transactionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionCommitCodec_encodeResponse() { + int fileClientMessageIndex = 638; + ClientMessage encoded = TransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 639; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionCreateCodec.RequestParameters parameters = TransactionCreateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.timeout)); + assertTrue(isEqual(anInt, parameters.durability)); + assertTrue(isEqual(anInt, parameters.transactionType)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionCreateCodec_encodeResponse() { + int fileClientMessageIndex = 640; + ClientMessage encoded = TransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 641; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TransactionRollbackCodec.RequestParameters parameters = TransactionRollbackCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.transactionId)); + assertTrue(isEqual(aLong, parameters.threadId)); + } + + @Test + public void test_TransactionRollbackCodec_encodeResponse() { + int fileClientMessageIndex = 642; + ClientMessage encoded = TransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { + int fileClientMessageIndex = 643; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryPublisherCreateWithValueCodec.RequestParameters parameters = ContinuousQueryPublisherCreateWithValueCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(anInt, parameters.batchSize)); + assertTrue(isEqual(anInt, parameters.bufferSize)); + assertTrue(isEqual(aLong, parameters.delaySeconds)); + assertTrue(isEqual(aBoolean, parameters.populate)); + assertTrue(isEqual(aBoolean, parameters.coalesce)); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeResponse() { + int fileClientMessageIndex = 644; + ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { + int fileClientMessageIndex = 645; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryPublisherCreateCodec.RequestParameters parameters = ContinuousQueryPublisherCreateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + assertTrue(isEqual(aData, parameters.predicate)); + assertTrue(isEqual(anInt, parameters.batchSize)); + assertTrue(isEqual(anInt, parameters.bufferSize)); + assertTrue(isEqual(aLong, parameters.delaySeconds)); + assertTrue(isEqual(aBoolean, parameters.populate)); + assertTrue(isEqual(aBoolean, parameters.coalesce)); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_encodeResponse() { + int fileClientMessageIndex = 646; + ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryMadePublishableCodec.RequestParameters parameters = ContinuousQueryMadePublishableCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_encodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodec.RequestParameters parameters = ContinuousQueryAddListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.listenerName)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { + int fileClientMessageIndex = 651; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheSingleEvent(aQueryCacheEventData); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { + int fileClientMessageIndex = 652; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheBatchEvent(aListOfQueryCacheEventData, aString, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQuerySetReadCursorCodec.RequestParameters parameters = ContinuousQuerySetReadCursorCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + assertTrue(isEqual(aLong, parameters.sequence)); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_encodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryDestroyCacheCodec.RequestParameters parameters = ContinuousQueryDestroyCacheCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(aString, parameters.cacheName)); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_encodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeRequest() { + int fileClientMessageIndex = 657; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeResponse() { + int fileClientMessageIndex = 658; + ClientMessage encoded = RingbufferSizeCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 659; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferTailSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 660; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 661; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferHeadSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 662; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 663; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 664; + ClientMessage encoded = RingbufferCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 665; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 666; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferAddCodec.RequestParameters parameters = RingbufferAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.overflowPolicy)); + assertTrue(isEqual(aData, parameters.value)); + } + + @Test + public void test_RingbufferAddCodec_encodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage encoded = RingbufferAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeRequest() { + int fileClientMessageIndex = 669; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferReadOneCodec.RequestParameters parameters = RingbufferReadOneCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.sequence)); + } + + @Test + public void test_RingbufferReadOneCodec_encodeResponse() { + int fileClientMessageIndex = 670; + ClientMessage encoded = RingbufferReadOneCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 671; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferAddAllCodec.RequestParameters parameters = RingbufferAddAllCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfData, parameters.valueList)); + assertTrue(isEqual(anInt, parameters.overflowPolicy)); + } + + @Test + public void test_RingbufferAddAllCodec_encodeResponse() { + int fileClientMessageIndex = 672; + ClientMessage encoded = RingbufferAddAllCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadManyCodec_decodeRequest() { + int fileClientMessageIndex = 673; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + RingbufferReadManyCodec.RequestParameters parameters = RingbufferReadManyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.startSequence)); + assertTrue(isEqual(anInt, parameters.minCount)); + assertTrue(isEqual(anInt, parameters.maxCount)); + assertTrue(isEqual(aData, parameters.filter)); + } + + @Test + public void test_RingbufferReadManyCodec_encodeResponse() { + int fileClientMessageIndex = 674; + ClientMessage encoded = RingbufferReadManyCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 675; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 676; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 677; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 678; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorSubmitToPartitionCodec.RequestParameters parameters = DurableExecutorSubmitToPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aData, parameters.callable)); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { + int fileClientMessageIndex = 681; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorRetrieveResultCodec.RequestParameters parameters = DurableExecutorRetrieveResultCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.sequence)); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_encodeResponse() { + int fileClientMessageIndex = 682; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 683; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorDisposeResultCodec.RequestParameters parameters = DurableExecutorDisposeResultCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.sequence)); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_encodeResponse() { + int fileClientMessageIndex = 684; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 685; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DurableExecutorRetrieveAndDisposeResultCodec.RequestParameters parameters = DurableExecutorRetrieveAndDisposeResultCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.sequence)); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeResponse() { + int fileClientMessageIndex = 686; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CardinalityEstimatorAddCodec.RequestParameters parameters = CardinalityEstimatorAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.hash)); + } + + @Test + public void test_CardinalityEstimatorAddCodec_encodeResponse() { + int fileClientMessageIndex = 688; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeRequest() { + int fileClientMessageIndex = 689; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CardinalityEstimatorEstimateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { + int fileClientMessageIndex = 690; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 691; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorShutdownCodec.RequestParameters parameters = ScheduledExecutorShutdownCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 692; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 693; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorSubmitToPartitionCodec.RequestParameters parameters = ScheduledExecutorSubmitToPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aByte, parameters.type)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aData, parameters.task)); + assertTrue(isEqual(aLong, parameters.initialDelayInMillis)); + assertTrue(isEqual(aLong, parameters.periodInMillis)); + assertTrue(parameters.isAutoDisposableExists); + assertTrue(isEqual(aBoolean, parameters.autoDisposable)); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 694; + ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 695; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorSubmitToMemberCodec.RequestParameters parameters = ScheduledExecutorSubmitToMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aByte, parameters.type)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aData, parameters.task)); + assertTrue(isEqual(aLong, parameters.initialDelayInMillis)); + assertTrue(isEqual(aLong, parameters.periodInMillis)); + assertTrue(parameters.isAutoDisposableExists); + assertTrue(isEqual(aBoolean, parameters.autoDisposable)); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_encodeResponse() { + int fileClientMessageIndex = 696; + ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeRequest() { + int fileClientMessageIndex = 697; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ScheduledExecutorGetAllScheduledFuturesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { + int fileClientMessageIndex = 698; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeResponse(aListOfScheduledTaskHandler); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 699; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 700; + ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 701; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetStatsFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 702; + ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 703; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetDelayFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 704; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 705; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetDelayFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 706; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 707; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorCancelFromPartitionCodec.RequestParameters parameters = ScheduledExecutorCancelFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aBoolean, parameters.mayInterruptIfRunning)); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 708; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 709; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorCancelFromMemberCodec.RequestParameters parameters = ScheduledExecutorCancelFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + assertTrue(isEqual(aBoolean, parameters.mayInterruptIfRunning)); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 710; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 711; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsCancelledFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 712; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 713; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsCancelledFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 714; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 715; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsDoneFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 716; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 717; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorIsDoneFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 718; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 719; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetResultFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetResultFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 720; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 721; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorGetResultFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetResultFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 722; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 723; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorDisposeFromPartitionCodec.RequestParameters parameters = ScheduledExecutorDisposeFromPartitionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeResponse() { + int fileClientMessageIndex = 724; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 725; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ScheduledExecutorDisposeFromMemberCodec.RequestParameters parameters = ScheduledExecutorDisposeFromMemberCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.schedulerName)); + assertTrue(isEqual(aString, parameters.taskName)); + assertTrue(isEqual(aUUID, parameters.memberUuid)); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_encodeResponse() { + int fileClientMessageIndex = 726; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 727; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddMultiMapConfigCodec.RequestParameters parameters = DynamicConfigAddMultiMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.collectionType)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + assertTrue(isEqual(aBoolean, parameters.binary)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 728; + ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { + int fileClientMessageIndex = 729; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddRingbufferConfigCodec.RequestParameters parameters = DynamicConfigAddRingbufferConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.capacity)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(aRingbufferStoreConfigHolder, parameters.ringbufferStoreConfig)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_encodeResponse() { + int fileClientMessageIndex = 730; + ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 731; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddCardinalityEstimatorConfigCodec.RequestParameters parameters = DynamicConfigAddCardinalityEstimatorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 732; + ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_decodeRequest() { + int fileClientMessageIndex = 733; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddListConfigCodec.RequestParameters parameters = DynamicConfigAddListConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_encodeResponse() { + int fileClientMessageIndex = 734; + ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 735; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddSetConfigCodec.RequestParameters parameters = DynamicConfigAddSetConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_encodeResponse() { + int fileClientMessageIndex = 736; + ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 737; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddReplicatedMapConfigCodec.RequestParameters parameters = DynamicConfigAddReplicatedMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(aBoolean, parameters.asyncFillup)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 738; + ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 739; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddTopicConfigCodec.RequestParameters parameters = DynamicConfigAddTopicConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.globalOrderingEnabled)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aBoolean, parameters.multiThreadingEnabled)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_encodeResponse() { + int fileClientMessageIndex = 740; + ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 741; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddExecutorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.poolSize)); + assertTrue(isEqual(anInt, parameters.queueCapacity)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 742; + ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 743; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddDurableExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddDurableExecutorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.poolSize)); + assertTrue(isEqual(anInt, parameters.durability)); + assertTrue(isEqual(anInt, parameters.capacity)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(parameters.isStatisticsEnabledExists); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 744; + ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 745; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddScheduledExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddScheduledExecutorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.poolSize)); + assertTrue(isEqual(anInt, parameters.durability)); + assertTrue(isEqual(anInt, parameters.capacity)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(parameters.isStatisticsEnabledExists); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(parameters.isCapacityPolicyExists); + assertTrue(isEqual(aByte, parameters.capacityPolicy)); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 746; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { + int fileClientMessageIndex = 747; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddQueueConfigCodec.RequestParameters parameters = DynamicConfigAddQueueConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(anInt, parameters.emptyQueueTtl)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aQueueStoreConfigHolder, parameters.queueStoreConfig)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(parameters.isPriorityComparatorClassNameExists); + assertTrue(isEqual(aString, parameters.priorityComparatorClassName)); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_encodeResponse() { + int fileClientMessageIndex = 748; + ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 749; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddMapConfigCodec.RequestParameters parameters = DynamicConfigAddMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(anInt, parameters.maxIdleSeconds)); + assertTrue(isEqual(anEvictionConfigHolder, parameters.evictionConfig)); + assertTrue(isEqual(aBoolean, parameters.readBackupData)); + assertTrue(isEqual(aString, parameters.cacheDeserializedValues)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.partitionLostListenerConfigs)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aMapStoreConfigHolder, parameters.mapStoreConfig)); + assertTrue(isEqual(aNearCacheConfigHolder, parameters.nearCacheConfig)); + assertTrue(isEqual(aWanReplicationRef, parameters.wanReplicationRef)); + assertTrue(isEqual(aListOfIndexConfigs, parameters.indexConfigs)); + assertTrue(isEqual(aListOfAttributeConfigs, parameters.attributeConfigs)); + assertTrue(isEqual(aListOfQueryCacheConfigHolders, parameters.queryCacheConfigs)); + assertTrue(isEqual(aString, parameters.partitioningStrategyClassName)); + assertTrue(isEqual(aData, parameters.partitioningStrategyImplementation)); + assertTrue(isEqual(aHotRestartConfig, parameters.hotRestartConfig)); + assertTrue(isEqual(anEventJournalConfig, parameters.eventJournalConfig)); + assertTrue(isEqual(aMerkleTreeConfig, parameters.merkleTreeConfig)); + assertTrue(isEqual(anInt, parameters.metadataPolicy)); + assertTrue(parameters.isPerEntryStatsEnabledExists); + assertTrue(isEqual(aBoolean, parameters.perEntryStatsEnabled)); + assertTrue(parameters.isDataPersistenceConfigExists); + assertTrue(isEqual(aDataPersistenceConfig, parameters.dataPersistenceConfig)); + assertTrue(parameters.isTieredStoreConfigExists); + assertTrue(isEqual(aTieredStoreConfig, parameters.tieredStoreConfig)); + assertTrue(parameters.isPartitioningAttributeConfigsExists); + assertTrue(isEqual(aListOfPartitioningAttributeConfigs, parameters.partitioningAttributeConfigs)); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 750; + ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 751; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddReliableTopicConfigCodec.RequestParameters parameters = DynamicConfigAddReliableTopicConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.listenerConfigs)); + assertTrue(isEqual(anInt, parameters.readBatchSize)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.topicOverloadPolicy)); + assertTrue(isEqual(aData, parameters.executor)); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_encodeResponse() { + int fileClientMessageIndex = 752; + ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { + int fileClientMessageIndex = 753; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddCacheConfigCodec.RequestParameters parameters = DynamicConfigAddCacheConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.keyType)); + assertTrue(isEqual(aString, parameters.valueType)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aBoolean, parameters.managementEnabled)); + assertTrue(isEqual(aBoolean, parameters.readThrough)); + assertTrue(isEqual(aBoolean, parameters.writeThrough)); + assertTrue(isEqual(aString, parameters.cacheLoaderFactory)); + assertTrue(isEqual(aString, parameters.cacheWriterFactory)); + assertTrue(isEqual(aString, parameters.cacheLoader)); + assertTrue(isEqual(aString, parameters.cacheWriter)); + assertTrue(isEqual(anInt, parameters.backupCount)); + assertTrue(isEqual(anInt, parameters.asyncBackupCount)); + assertTrue(isEqual(aString, parameters.inMemoryFormat)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + assertTrue(isEqual(aString, parameters.mergePolicy)); + assertTrue(isEqual(anInt, parameters.mergeBatchSize)); + assertTrue(isEqual(aBoolean, parameters.disablePerEntryInvalidationEvents)); + assertTrue(isEqual(aListOfListenerConfigHolders, parameters.partitionLostListenerConfigs)); + assertTrue(isEqual(aString, parameters.expiryPolicyFactoryClassName)); + assertTrue(isEqual(aTimedExpiryPolicyFactoryConfig, parameters.timedExpiryPolicyFactoryConfig)); + assertTrue(isEqual(aListOfCacheSimpleEntryListenerConfigs, parameters.cacheEntryListeners)); + assertTrue(isEqual(anEvictionConfigHolder, parameters.evictionConfig)); + assertTrue(isEqual(aWanReplicationRef, parameters.wanReplicationRef)); + assertTrue(isEqual(anEventJournalConfig, parameters.eventJournalConfig)); + assertTrue(isEqual(aHotRestartConfig, parameters.hotRestartConfig)); + assertTrue(parameters.isMerkleTreeConfigExists); + assertTrue(isEqual(aMerkleTreeConfig, parameters.merkleTreeConfig)); + assertTrue(parameters.isDataPersistenceConfigExists); + assertTrue(isEqual(aDataPersistenceConfig, parameters.dataPersistenceConfig)); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { + int fileClientMessageIndex = 754; + ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 755; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddFlakeIdGeneratorConfigCodec.RequestParameters parameters = DynamicConfigAddFlakeIdGeneratorConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.prefetchCount)); + assertTrue(isEqual(aLong, parameters.prefetchValidity)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aLong, parameters.nodeIdOffset)); + assertTrue(isEqual(aLong, parameters.epochStart)); + assertTrue(isEqual(anInt, parameters.bitsSequence)); + assertTrue(isEqual(anInt, parameters.bitsNodeId)); + assertTrue(isEqual(aLong, parameters.allowedFutureMillis)); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 756; + ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddPNCounterConfigCodec.RequestParameters parameters = DynamicConfigAddPNCounterConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.replicaCount)); + assertTrue(isEqual(aBoolean, parameters.statisticsEnabled)); + assertTrue(isEqual(aString, parameters.splitBrainProtectionName)); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_encodeResponse() { + int fileClientMessageIndex = 758; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_decodeRequest() { + int fileClientMessageIndex = 759; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + DynamicConfigAddDataConnectionConfigCodec.RequestParameters parameters = DynamicConfigAddDataConnectionConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.type)); + assertTrue(isEqual(aBoolean, parameters.shared)); + assertTrue(isEqual(aMapOfStringToString, parameters.properties)); + } + + @Test + public void test_DynamicConfigAddDataConnectionConfigCodec_encodeResponse() { + int fileClientMessageIndex = 760; + ClientMessage encoded = DynamicConfigAddDataConnectionConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { + int fileClientMessageIndex = 761; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + FlakeIdGeneratorNewIdBatchCodec.RequestParameters parameters = FlakeIdGeneratorNewIdBatchCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(anInt, parameters.batchSize)); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_encodeResponse() { + int fileClientMessageIndex = 762; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeResponse(aLong, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeRequest() { + int fileClientMessageIndex = 763; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterGetCodec.RequestParameters parameters = PNCounterGetCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(aUUID, parameters.targetReplicaUUID)); + } + + @Test + public void test_PNCounterGetCodec_encodeResponse() { + int fileClientMessageIndex = 764; + ClientMessage encoded = PNCounterGetCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterAddCodec_decodeRequest() { + int fileClientMessageIndex = 765; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + PNCounterAddCodec.RequestParameters parameters = PNCounterAddCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aLong, parameters.delta)); + assertTrue(isEqual(aBoolean, parameters.getBeforeUpdate)); + assertTrue(isEqual(aListOfUuidToLong, parameters.replicaTimestamps)); + assertTrue(isEqual(aUUID, parameters.targetReplicaUUID)); + } + + @Test + public void test_PNCounterAddCodec_encodeResponse() { + int fileClientMessageIndex = 766; + ClientMessage encoded = PNCounterAddCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, PNCounterGetConfiguredReplicaCountCodec.decodeRequest(fromFile))); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeRequest() { + int fileClientMessageIndex = 769; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CPGroupCreateCPGroupCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeResponse() { + int fileClientMessageIndex = 770; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeResponse(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { + int fileClientMessageIndex = 771; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPGroupDestroyCPObjectCodec.RequestParameters parameters = CPGroupDestroyCPObjectCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.serviceName)); + assertTrue(isEqual(aString, parameters.objectName)); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_encodeResponse() { + int fileClientMessageIndex = 772; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionCreateSessionCodec.RequestParameters parameters = CPSessionCreateSessionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aString, parameters.endpointName)); + } + + @Test + public void test_CPSessionCreateSessionCodec_encodeResponse() { + int fileClientMessageIndex = 774; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeResponse(aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeRequest() { + int fileClientMessageIndex = 775; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionCloseSessionCodec.RequestParameters parameters = CPSessionCloseSessionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aLong, parameters.sessionId)); + } + + @Test + public void test_CPSessionCloseSessionCodec_encodeResponse() { + int fileClientMessageIndex = 776; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { + int fileClientMessageIndex = 777; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSessionHeartbeatSessionCodec.RequestParameters parameters = CPSessionHeartbeatSessionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aRaftGroupId, parameters.groupId)); + assertTrue(isEqual(aLong, parameters.sessionId)); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_encodeResponse() { + int fileClientMessageIndex = 778; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeRequest() { + int fileClientMessageIndex = 779; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPSessionGenerateThreadIdCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { + int fileClientMessageIndex = 780; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCReadMetricsCodec.RequestParameters parameters = MCReadMetricsCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aLong, parameters.fromSequence)); + } + + @Test + public void test_MCReadMetricsCodec_encodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage encoded = MCReadMetricsCodec.encodeResponse(aListOfLongToByteArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeRequest() { + int fileClientMessageIndex = 783; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MCChangeClusterStateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCChangeClusterStateCodec_encodeResponse() { + int fileClientMessageIndex = 784; + ClientMessage encoded = MCChangeClusterStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 785; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMapConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 786; + ClientMessage encoded = MCGetMapConfigCodec.encodeResponse(anInt, anInt, anInt, anInt, anInt, anInt, anInt, aBoolean, anInt, aString, aListOfIndexConfigs); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 787; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCUpdateMapConfigCodec.RequestParameters parameters = MCUpdateMapConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.mapName)); + assertTrue(isEqual(anInt, parameters.timeToLiveSeconds)); + assertTrue(isEqual(anInt, parameters.maxIdleSeconds)); + assertTrue(isEqual(anInt, parameters.evictionPolicy)); + assertTrue(isEqual(aBoolean, parameters.readBackupData)); + assertTrue(isEqual(anInt, parameters.maxSize)); + assertTrue(isEqual(anInt, parameters.maxSizePolicy)); + } + + @Test + public void test_MCUpdateMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 788; + ClientMessage encoded = MCUpdateMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeRequest() { + int fileClientMessageIndex = 789; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage encoded = MCGetMemberConfigCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeRequest() { + int fileClientMessageIndex = 791; + } + + @Test + public void test_MCRunGcCodec_encodeResponse() { + int fileClientMessageIndex = 792; + ClientMessage encoded = MCRunGcCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeRequest() { + int fileClientMessageIndex = 793; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCGetThreadDumpCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetThreadDumpCodec_encodeResponse() { + int fileClientMessageIndex = 794; + ClientMessage encoded = MCGetThreadDumpCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeRequest() { + int fileClientMessageIndex = 795; + } + + @Test + public void test_MCShutdownMemberCodec_encodeResponse() { + int fileClientMessageIndex = 796; + ClientMessage encoded = MCShutdownMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeRequest() { + int fileClientMessageIndex = 797; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeResponse() { + int fileClientMessageIndex = 798; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeRequest() { + int fileClientMessageIndex = 799; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeResponse() { + int fileClientMessageIndex = 800; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeResponse(aListOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeRequest() { + int fileClientMessageIndex = 801; + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeResponse() { + int fileClientMessageIndex = 802; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 803; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCMatchMCConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeResponse() { + int fileClientMessageIndex = 804; + ClientMessage encoded = MCMatchMCConfigCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 805; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCApplyMCConfigCodec.RequestParameters parameters = MCApplyMCConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.eTag)); + assertTrue(isEqual(anInt, parameters.clientBwListMode)); + assertTrue(isEqual(aListOfClientBwListEntries, parameters.clientBwListEntries)); + } + + @Test + public void test_MCApplyMCConfigCodec_encodeResponse() { + int fileClientMessageIndex = 806; + ClientMessage encoded = MCApplyMCConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 807; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 808; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeResponse(aByte, aString, aString, aLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeRequest() { + int fileClientMessageIndex = 809; + } + + @Test + public void test_MCShutdownClusterCodec_encodeResponse() { + int fileClientMessageIndex = 810; + ClientMessage encoded = MCShutdownClusterCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeRequest() { + int fileClientMessageIndex = 811; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCChangeClusterVersionCodec.RequestParameters parameters = MCChangeClusterVersionCodec.decodeRequest(fromFile); + assertTrue(isEqual(aByte, parameters.majorVersion)); + assertTrue(isEqual(aByte, parameters.minorVersion)); + } + + @Test + public void test_MCChangeClusterVersionCodec_encodeResponse() { + int fileClientMessageIndex = 812; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeRequest() { + int fileClientMessageIndex = 813; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCRunScriptCodec.RequestParameters parameters = MCRunScriptCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.engine)); + assertTrue(isEqual(aString, parameters.script)); + } + + @Test + public void test_MCRunScriptCodec_encodeResponse() { + int fileClientMessageIndex = 814; + ClientMessage encoded = MCRunScriptCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeRequest() { + int fileClientMessageIndex = 815; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCRunConsoleCommandCodec.RequestParameters parameters = MCRunConsoleCommandCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.namespace)); + assertTrue(isEqual(aString, parameters.command)); + } + + @Test + public void test_MCRunConsoleCommandCodec_encodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeRequest() { + int fileClientMessageIndex = 817; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCChangeWanReplicationStateCodec.RequestParameters parameters = MCChangeWanReplicationStateCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + assertTrue(isEqual(aByte, parameters.newState)); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_encodeResponse() { + int fileClientMessageIndex = 818; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeRequest() { + int fileClientMessageIndex = 819; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCClearWanQueuesCodec.RequestParameters parameters = MCClearWanQueuesCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + } + + @Test + public void test_MCClearWanQueuesCodec_encodeResponse() { + int fileClientMessageIndex = 820; + ClientMessage encoded = MCClearWanQueuesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCAddWanBatchPublisherConfigCodec.RequestParameters parameters = MCAddWanBatchPublisherConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aString, parameters.targetCluster)); + assertTrue(isEqual(aString, parameters.publisherId)); + assertTrue(isEqual(aString, parameters.endpoints)); + assertTrue(isEqual(anInt, parameters.queueCapacity)); + assertTrue(isEqual(anInt, parameters.batchSize)); + assertTrue(isEqual(anInt, parameters.batchMaxDelayMillis)); + assertTrue(isEqual(anInt, parameters.responseTimeoutMillis)); + assertTrue(isEqual(anInt, parameters.ackType)); + assertTrue(isEqual(anInt, parameters.queueFullBehavior)); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_encodeResponse() { + int fileClientMessageIndex = 822; + ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeResponse(aListOfStrings, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeRequest() { + int fileClientMessageIndex = 823; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCWanSyncMapCodec.RequestParameters parameters = MCWanSyncMapCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + assertTrue(isEqual(anInt, parameters.wanSyncType)); + assertTrue(isEqual(aString, parameters.mapName)); + } + + @Test + public void test_MCWanSyncMapCodec_encodeResponse() { + int fileClientMessageIndex = 824; + ClientMessage encoded = MCWanSyncMapCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeRequest() { + int fileClientMessageIndex = 825; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MCCheckWanConsistencyCodec.RequestParameters parameters = MCCheckWanConsistencyCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.wanReplicationName)); + assertTrue(isEqual(aString, parameters.wanPublisherId)); + assertTrue(isEqual(aString, parameters.mapName)); + } + + @Test + public void test_MCCheckWanConsistencyCodec_encodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeRequest() { + int fileClientMessageIndex = 827; + } + + @Test + public void test_MCPollMCEventsCodec_encodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage encoded = MCPollMCEventsCodec.encodeResponse(aListOfMCEvents); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeRequest() { + int fileClientMessageIndex = 829; + } + + @Test + public void test_MCGetCPMembersCodec_encodeResponse() { + int fileClientMessageIndex = 830; + ClientMessage encoded = MCGetCPMembersCodec.encodeResponse(aListOfUUIDToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 831; + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 832; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 833; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCRemoveCPMemberCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 834; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeRequest() { + int fileClientMessageIndex = 835; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeResponse() { + int fileClientMessageIndex = 836; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeRequest() { + int fileClientMessageIndex = 837; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeResponse() { + int fileClientMessageIndex = 838; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeRequest() { + int fileClientMessageIndex = 839; + } + + @Test + public void test_MCTriggerForceStartCodec_encodeResponse() { + int fileClientMessageIndex = 840; + ClientMessage encoded = MCTriggerForceStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 841; + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 842; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 843; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 844; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_decodeRequest() { + int fileClientMessageIndex = 845; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCResetQueueAgeStatisticsCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCResetQueueAgeStatisticsCodec_encodeResponse() { + int fileClientMessageIndex = 846; + ClientMessage encoded = MCResetQueueAgeStatisticsCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReloadConfigCodec_decodeRequest() { + int fileClientMessageIndex = 847; + } + + @Test + public void test_MCReloadConfigCodec_encodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage encoded = MCReloadConfigCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateConfigCodec_decodeRequest() { + int fileClientMessageIndex = 849; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCUpdateConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCUpdateConfigCodec_encodeResponse() { + int fileClientMessageIndex = 850; + ClientMessage encoded = MCUpdateConfigCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecute_reservedCodec_decodeRequest() { + int fileClientMessageIndex = 851; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecute_reservedCodec.RequestParameters parameters = SqlExecute_reservedCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.sql)); + assertTrue(isEqual(aListOfData, parameters.parameters)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + } + + @Test + public void test_SqlExecute_reservedCodec_encodeResponse() { + int fileClientMessageIndex = 852; + ClientMessage encoded = SqlExecute_reservedCodec.encodeResponse(anSqlQueryId, aListOfSqlColumnMetadata, aListOfListOfData, aBoolean, aLong, anSqlError); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetch_reservedCodec_decodeRequest() { + int fileClientMessageIndex = 853; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetch_reservedCodec.RequestParameters parameters = SqlFetch_reservedCodec.decodeRequest(fromFile); + assertTrue(isEqual(anSqlQueryId, parameters.queryId)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + } + + @Test + public void test_SqlFetch_reservedCodec_encodeResponse() { + int fileClientMessageIndex = 854; + ClientMessage encoded = SqlFetch_reservedCodec.encodeResponse(aListOfListOfData, aBoolean, anSqlError); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeRequest() { + int fileClientMessageIndex = 855; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anSqlQueryId, SqlCloseCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SqlCloseCodec_encodeResponse() { + int fileClientMessageIndex = 856; + ClientMessage encoded = SqlCloseCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeRequest() { + int fileClientMessageIndex = 857; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecuteCodec.RequestParameters parameters = SqlExecuteCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.sql)); + assertTrue(isEqual(aListOfData, parameters.parameters)); + assertTrue(isEqual(aLong, parameters.timeoutMillis)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + assertTrue(isEqual(aString, parameters.schema)); + assertTrue(isEqual(aByte, parameters.expectedResultType)); + assertTrue(isEqual(anSqlQueryId, parameters.queryId)); + assertTrue(parameters.isSkipUpdateStatisticsExists); + assertTrue(isEqual(aBoolean, parameters.skipUpdateStatistics)); + } + + @Test + public void test_SqlExecuteCodec_encodeResponse() { + int fileClientMessageIndex = 858; + ClientMessage encoded = SqlExecuteCodec.encodeResponse(aListOfSqlColumnMetadata, aSqlPage, aLong, anSqlError, aBoolean, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeRequest() { + int fileClientMessageIndex = 859; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetchCodec.RequestParameters parameters = SqlFetchCodec.decodeRequest(fromFile); + assertTrue(isEqual(anSqlQueryId, parameters.queryId)); + assertTrue(isEqual(anInt, parameters.cursorBufferSize)); + } + + @Test + public void test_SqlFetchCodec_encodeResponse() { + int fileClientMessageIndex = 860; + ClientMessage encoded = SqlFetchCodec.encodeResponse(aSqlPage, anSqlError); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlMappingDdlCodec_decodeRequest() { + int fileClientMessageIndex = 861; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SqlMappingDdlCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SqlMappingDdlCodec_encodeResponse() { + int fileClientMessageIndex = 862; + ClientMessage encoded = SqlMappingDdlCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 863; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 864; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEvent() { + int fileClientMessageIndex = 865; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeMembershipEventEvent(aCpMember, aByte); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 866; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 867; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 868; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 869; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailabilityEventEvent() { + int fileClientMessageIndex = 870; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeGroupAvailabilityEventEvent(aRaftGroupId, aListOfCpMembers, aListOfCpMembers); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 871; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 872; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCodec_decodeRequest() { + int fileClientMessageIndex = 873; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCodec.RequestParameters parameters = ExperimentalAuthenticationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(aString, parameters.username)); + assertTrue(isEqual(aString, parameters.password)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ExperimentalAuthenticationCodec_encodeResponse() { + int fileClientMessageIndex = 874; + ClientMessage encoded = ExperimentalAuthenticationCodec.encodeResponse(aByte, anAddress, aUUID, aByte, aString, anInt, aUUID, aBoolean, aListOfIntegers, aByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_decodeRequest() { + int fileClientMessageIndex = 875; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalAuthenticationCustomCodec.RequestParameters parameters = ExperimentalAuthenticationCustomCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.clusterName)); + assertTrue(isEqual(aByteArray, parameters.credentials)); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aString, parameters.clientType)); + assertTrue(isEqual(aByte, parameters.serializationVersion)); + assertTrue(isEqual(aString, parameters.clientHazelcastVersion)); + assertTrue(isEqual(aString, parameters.clientName)); + assertTrue(isEqual(aListOfStrings, parameters.labels)); + } + + @Test + public void test_ExperimentalAuthenticationCustomCodec_encodeResponse() { + int fileClientMessageIndex = 876; + ClientMessage encoded = ExperimentalAuthenticationCustomCodec.encodeResponse(aByte, anAddress, aUUID, aByte, aString, anInt, aUUID, aBoolean, aListOfIntegers, aByteArray); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_decodeRequest() { + int fileClientMessageIndex = 877; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ExperimentalTpcAuthenticationCodec.RequestParameters parameters = ExperimentalTpcAuthenticationCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.uuid)); + assertTrue(isEqual(aByteArray, parameters.token)); + } + + @Test + public void test_ExperimentalTpcAuthenticationCodec_encodeResponse() { + int fileClientMessageIndex = 878; + ClientMessage encoded = ExperimentalTpcAuthenticationCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetSubmitJobCodec_decodeRequest() { + int fileClientMessageIndex = 879; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetSubmitJobCodec.RequestParameters parameters = JetSubmitJobCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aData, parameters.dag)); + assertTrue(isEqual(aData, parameters.jobConfig)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(aUUID, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetSubmitJobCodec_encodeResponse() { + int fileClientMessageIndex = 880; + ClientMessage encoded = JetSubmitJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetTerminateJobCodec_decodeRequest() { + int fileClientMessageIndex = 881; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetTerminateJobCodec.RequestParameters parameters = JetTerminateJobCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(anInt, parameters.terminateMode)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(aUUID, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetTerminateJobCodec_encodeResponse() { + int fileClientMessageIndex = 882; + ClientMessage encoded = JetTerminateJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobStatusCodec_decodeRequest() { + int fileClientMessageIndex = 883; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobStatusCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetGetJobStatusCodec_encodeResponse() { + int fileClientMessageIndex = 884; + ClientMessage encoded = JetGetJobStatusCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobIdsCodec_decodeRequest() { + int fileClientMessageIndex = 885; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobIdsCodec.RequestParameters parameters = JetGetJobIdsCodec.decodeRequest(fromFile); + assertTrue(parameters.isOnlyNameExists); + assertTrue(isEqual(aString, parameters.onlyName)); + assertTrue(parameters.isOnlyJobIdExists); + assertTrue(isEqual(aLong, parameters.onlyJobId)); + } + + @Test + public void test_JetGetJobIdsCodec_encodeResponse() { + int fileClientMessageIndex = 886; + ClientMessage encoded = JetGetJobIdsCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetJoinSubmittedJobCodec_decodeRequest() { + int fileClientMessageIndex = 887; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetJoinSubmittedJobCodec.RequestParameters parameters = JetJoinSubmittedJobCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(aUUID, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetJoinSubmittedJobCodec_encodeResponse() { + int fileClientMessageIndex = 888; + ClientMessage encoded = JetJoinSubmittedJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_decodeRequest() { + int fileClientMessageIndex = 889; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobSubmissionTimeCodec.RequestParameters parameters = JetGetJobSubmissionTimeCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(aUUID, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetGetJobSubmissionTimeCodec_encodeResponse() { + int fileClientMessageIndex = 890; + ClientMessage encoded = JetGetJobSubmissionTimeCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobConfigCodec_decodeRequest() { + int fileClientMessageIndex = 891; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetGetJobConfigCodec.RequestParameters parameters = JetGetJobConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(parameters.isLightJobCoordinatorExists); + assertTrue(isEqual(aUUID, parameters.lightJobCoordinator)); + } + + @Test + public void test_JetGetJobConfigCodec_encodeResponse() { + int fileClientMessageIndex = 892; + ClientMessage encoded = JetGetJobConfigCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetResumeJobCodec_decodeRequest() { + int fileClientMessageIndex = 893; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetResumeJobCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetResumeJobCodec_encodeResponse() { + int fileClientMessageIndex = 894; + ClientMessage encoded = JetResumeJobCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExportSnapshotCodec_decodeRequest() { + int fileClientMessageIndex = 895; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetExportSnapshotCodec.RequestParameters parameters = JetExportSnapshotCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aString, parameters.name)); + assertTrue(isEqual(aBoolean, parameters.cancelJob)); + } + + @Test + public void test_JetExportSnapshotCodec_encodeResponse() { + int fileClientMessageIndex = 896; + ClientMessage encoded = JetExportSnapshotCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSummaryListCodec_decodeRequest() { + int fileClientMessageIndex = 897; + } + + @Test + public void test_JetGetJobSummaryListCodec_encodeResponse() { + int fileClientMessageIndex = 898; + ClientMessage encoded = JetGetJobSummaryListCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetExistsDistributedObjectCodec_decodeRequest() { + int fileClientMessageIndex = 899; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetExistsDistributedObjectCodec.RequestParameters parameters = JetExistsDistributedObjectCodec.decodeRequest(fromFile); + assertTrue(isEqual(aString, parameters.serviceName)); + assertTrue(isEqual(aString, parameters.objectName)); + } + + @Test + public void test_JetExistsDistributedObjectCodec_encodeResponse() { + int fileClientMessageIndex = 900; + ClientMessage encoded = JetExistsDistributedObjectCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobMetricsCodec_decodeRequest() { + int fileClientMessageIndex = 901; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobMetricsCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetGetJobMetricsCodec_encodeResponse() { + int fileClientMessageIndex = 902; + ClientMessage encoded = JetGetJobMetricsCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_decodeRequest() { + int fileClientMessageIndex = 903; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetGetJobSuspensionCauseCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetGetJobSuspensionCauseCodec_encodeResponse() { + int fileClientMessageIndex = 904; + ClientMessage encoded = JetGetJobSuspensionCauseCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_decodeRequest() { + int fileClientMessageIndex = 905; + } + + @Test + public void test_JetGetJobAndSqlSummaryListCodec_encodeResponse() { + int fileClientMessageIndex = 906; + ClientMessage encoded = JetGetJobAndSqlSummaryListCodec.encodeResponse(aListJobAndSqlSummary); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetIsJobUserCancelledCodec_decodeRequest() { + int fileClientMessageIndex = 907; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, JetIsJobUserCancelledCodec.decodeRequest(fromFile))); + } + + @Test + public void test_JetIsJobUserCancelledCodec_encodeResponse() { + int fileClientMessageIndex = 908; + ClientMessage encoded = JetIsJobUserCancelledCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMetaDataCodec_decodeRequest() { + int fileClientMessageIndex = 909; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetUploadJobMetaDataCodec.RequestParameters parameters = JetUploadJobMetaDataCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.sessionId)); + assertTrue(isEqual(aBoolean, parameters.jarOnMember)); + assertTrue(isEqual(aString, parameters.fileName)); + assertTrue(isEqual(aString, parameters.sha256Hex)); + assertTrue(isEqual(aString, parameters.snapshotName)); + assertTrue(isEqual(aString, parameters.jobName)); + assertTrue(isEqual(aString, parameters.mainClass)); + assertTrue(isEqual(aListOfStrings, parameters.jobParameters)); + } + + @Test + public void test_JetUploadJobMetaDataCodec_encodeResponse() { + int fileClientMessageIndex = 910; + ClientMessage encoded = JetUploadJobMetaDataCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUploadJobMultipartCodec_decodeRequest() { + int fileClientMessageIndex = 911; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetUploadJobMultipartCodec.RequestParameters parameters = JetUploadJobMultipartCodec.decodeRequest(fromFile); + assertTrue(isEqual(aUUID, parameters.sessionId)); + assertTrue(isEqual(anInt, parameters.currentPartNumber)); + assertTrue(isEqual(anInt, parameters.totalPartNumber)); + assertTrue(isEqual(aByteArray, parameters.partData)); + assertTrue(isEqual(anInt, parameters.partSize)); + assertTrue(isEqual(aString, parameters.sha256Hex)); + } + + @Test + public void test_JetUploadJobMultipartCodec_encodeResponse() { + int fileClientMessageIndex = 912; + ClientMessage encoded = JetUploadJobMultipartCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetAddJobStatusListenerCodec_decodeRequest() { + int fileClientMessageIndex = 913; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetAddJobStatusListenerCodec.RequestParameters parameters = JetAddJobStatusListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aUUID, parameters.lightJobCoordinator)); + assertTrue(isEqual(aBoolean, parameters.localOnly)); + } + + @Test + public void test_JetAddJobStatusListenerCodec_encodeResponse() { + int fileClientMessageIndex = 914; + ClientMessage encoded = JetAddJobStatusListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetAddJobStatusListenerCodec_encodeJobStatusEvent() { + int fileClientMessageIndex = 915; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = JetAddJobStatusListenerCodec.encodeJobStatusEvent(aLong, anInt, anInt, aString, aBoolean); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_decodeRequest() { + int fileClientMessageIndex = 916; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetRemoveJobStatusListenerCodec.RequestParameters parameters = JetRemoveJobStatusListenerCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aUUID, parameters.registrationId)); + } + + @Test + public void test_JetRemoveJobStatusListenerCodec_encodeResponse() { + int fileClientMessageIndex = 917; + ClientMessage encoded = JetRemoveJobStatusListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_JetUpdateJobConfigCodec_decodeRequest() { + int fileClientMessageIndex = 918; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + JetUpdateJobConfigCodec.RequestParameters parameters = JetUpdateJobConfigCodec.decodeRequest(fromFile); + assertTrue(isEqual(aLong, parameters.jobId)); + assertTrue(isEqual(aData, parameters.deltaConfig)); + } + + @Test + public void test_JetUpdateJobConfigCodec_encodeResponse() { + int fileClientMessageIndex = 919; + ClientMessage encoded = JetUpdateJobConfigCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + private void compareClientMessages(ClientMessage binaryMessage, ClientMessage encodedMessage) { + ClientMessage.Frame binaryFrame, encodedFrame; + + ClientMessage.ForwardFrameIterator binaryFrameIterator = binaryMessage.frameIterator(); + ClientMessage.ForwardFrameIterator encodedFrameIterator = encodedMessage.frameIterator(); + assertTrue("Client message that is read from the binary file does not have any frames", binaryFrameIterator.hasNext()); + + while (binaryFrameIterator.hasNext()) { + binaryFrame = binaryFrameIterator.next(); + encodedFrame = encodedFrameIterator.next(); + assertNotNull("Encoded client message has less frames.", encodedFrame); + + if (binaryFrame.isEndFrame() && !encodedFrame.isEndFrame()) { + if (encodedFrame.isBeginFrame()) { + HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + encodedFrame = HazelcastClientUtil.fastForwardToEndFrame(encodedFrameIterator); + } + + boolean isFinal = binaryFrameIterator.peekNext() == null; + int flags = isFinal ? encodedFrame.flags | IS_FINAL_FLAG : encodedFrame.flags; + assertArrayEquals("Frames have different contents", binaryFrame.content, Arrays.copyOf(encodedFrame.content, binaryFrame.content.length)); + assertEquals("Frames have different flags", binaryFrame.flags, flags); + } + } +} \ No newline at end of file diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ReferenceObjects.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ReferenceObjects.java index e7b7cb105ff2..16f28d827c8e 100755 --- a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ReferenceObjects.java +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ReferenceObjects.java @@ -931,4 +931,8 @@ private static boolean isEqualStackTrace(StackTraceElement stackTraceElement1, S public static List aListOfPartitioningAttributeConfigs = Collections.singletonList( new PartitioningAttributeConfig(aString) ); + + public static List> aListOfSimpleEntryViews = Collections.singletonList( + aSimpleEntryView + ); } diff --git a/hazelcast/src/test/resources/2.7.protocol.compatibility.binary b/hazelcast/src/test/resources/2.7.protocol.compatibility.binary new file mode 100644 index 000000000000..178332fa6314 Binary files /dev/null and b/hazelcast/src/test/resources/2.7.protocol.compatibility.binary differ diff --git a/hazelcast/src/test/resources/2.7.protocol.compatibility.null.binary b/hazelcast/src/test/resources/2.7.protocol.compatibility.null.binary new file mode 100644 index 000000000000..35a676d91384 Binary files /dev/null and b/hazelcast/src/test/resources/2.7.protocol.compatibility.null.binary differ