From 6f143bc5426b6a6b36566bbd022911f6628fef02 Mon Sep 17 00:00:00 2001 From: petjot Date: Wed, 28 Oct 2020 19:18:13 +0100 Subject: [PATCH 01/12] Add Migration Listener on the client --- .../HazelcastClientInstanceImpl.java | 4 + .../DefaultMessageTaskFactoryProvider.java | 8 + .../ClientAddMigrationListenerCodec.java | 182 ++ .../ClientRemoveMigrationListenerCodec.java | 93 + .../codec/custom/MigrationStateCodec.java | 65 + .../task/AddMigrationListenerMessageTask.java | 149 ++ .../RemoveMigrationListenerMessageTask.java | 77 + .../impl/proxy/PartitionServiceProxy.java | 73 +- .../impl/spi/ClientPartitionService.java | 1 - .../internal/partition/IPartitionService.java | 6 + .../partition/MigrationEventHandler.java | 61 + .../partition/MigrationStateImpl.java | 21 + .../impl/InternalPartitionServiceImpl.java | 15 + .../impl/MigrationListenerAdapter.java | 25 +- .../partition/impl/PartitionEventManager.java | 89 +- .../ClientMigrationListenerTest.java | 232 +++ .../PartitionServiceProxyTest.java | 38 - .../ClientCompatibilityNullTest_2_1.java | 1676 +++++++++-------- .../ClientCompatibilityTest_2_1.java | 1676 +++++++++-------- .../MemberCompatibilityNullTest_2_1.java | 1658 ++++++++-------- .../MemberCompatibilityTest_2_1.java | 1658 ++++++++-------- .../compatibility/ReferenceObjects.java | 3 + .../impl/MigrationListenerAdapterTest.java | 4 +- .../PartitionMigrationListenerTest.java | 37 +- .../2.1.protocol.compatibility.binary | Bin 48880 -> 49181 bytes .../2.1.protocol.compatibility.null.binary | Bin 42481 -> 42782 bytes 26 files changed, 4503 insertions(+), 3348 deletions(-) create mode 100644 hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java create mode 100644 hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientRemoveMigrationListenerCodec.java create mode 100644 hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/custom/MigrationStateCodec.java create mode 100644 hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java create mode 100644 hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java create mode 100644 hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java create mode 100644 hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/clientside/HazelcastClientInstanceImpl.java b/hazelcast/src/main/java/com/hazelcast/client/impl/clientside/HazelcastClientInstanceImpl.java index 31bedd1feb402..8a0749b01f22b 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/clientside/HazelcastClientInstanceImpl.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/clientside/HazelcastClientInstanceImpl.java @@ -107,6 +107,7 @@ import com.hazelcast.map.impl.MapService; import com.hazelcast.multimap.MultiMap; import com.hazelcast.multimap.impl.MultiMapService; +import com.hazelcast.partition.MigrationListener; import com.hazelcast.partition.PartitionLostListener; import com.hazelcast.partition.PartitionService; import com.hazelcast.replicatedmap.ReplicatedMap; @@ -881,6 +882,9 @@ private void addClientConfigAddedListeners(Collection configuredL configuredListeners.stream().filter(listener -> listener instanceof DistributedObjectListener) .forEach(listener -> proxyManager.addDistributedObjectListener((DistributedObjectListener) listener)); + configuredListeners.stream().filter(listener -> listener instanceof MigrationListener) + .forEach(listener -> getPartitionService().addMigrationListener((MigrationListener) listener)); + configuredListeners.stream().filter(listener -> listener instanceof PartitionLostListener) .forEach(listener -> getPartitionService().addPartitionLostListener((PartitionLostListener) listener)); 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 1f70276494170..42ee58979f7ff 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 @@ -75,6 +75,7 @@ import com.hazelcast.client.impl.protocol.codec.CardinalityEstimatorEstimateCodec; import com.hazelcast.client.impl.protocol.codec.ClientAddClusterViewListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientAddDistributedObjectListenerCodec; +import com.hazelcast.client.impl.protocol.codec.ClientAddMigrationListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientAddPartitionLostListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientAuthenticationCodec; import com.hazelcast.client.impl.protocol.codec.ClientAuthenticationCustomCodec; @@ -86,6 +87,7 @@ import com.hazelcast.client.impl.protocol.codec.ClientLocalBackupListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientPingCodec; import com.hazelcast.client.impl.protocol.codec.ClientRemoveDistributedObjectListenerCodec; +import com.hazelcast.client.impl.protocol.codec.ClientRemoveMigrationListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientRemovePartitionLostListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientStatisticsCodec; import com.hazelcast.client.impl.protocol.codec.ClientTriggerPartitionAssignmentCodec; @@ -419,6 +421,7 @@ import com.hazelcast.client.impl.protocol.task.AddBackupListenerMessageTask; import com.hazelcast.client.impl.protocol.task.AddClusterViewListenerMessageTask; import com.hazelcast.client.impl.protocol.task.AddDistributedObjectListenerMessageTask; +import com.hazelcast.client.impl.protocol.task.AddMigrationListenerMessageTask; import com.hazelcast.client.impl.protocol.task.AddPartitionLostListenerMessageTask; import com.hazelcast.client.impl.protocol.task.AuthenticationCustomCredentialsMessageTask; import com.hazelcast.client.impl.protocol.task.AuthenticationMessageTask; @@ -430,6 +433,7 @@ import com.hazelcast.client.impl.protocol.task.GetDistributedObjectsMessageTask; import com.hazelcast.client.impl.protocol.task.PingMessageTask; import com.hazelcast.client.impl.protocol.task.RemoveDistributedObjectListenerMessageTask; +import com.hazelcast.client.impl.protocol.task.RemoveMigrationListenerMessageTask; import com.hazelcast.client.impl.protocol.task.RemovePartitionLostListenerMessageTask; import com.hazelcast.client.impl.protocol.task.TriggerPartitionAssignmentMessageTask; import com.hazelcast.client.impl.protocol.task.cache.CacheAddEntryListenerMessageTask; @@ -1464,6 +1468,10 @@ private void initializeGeneralTaskFactories() { (cm, con) -> new AddPartitionLostListenerMessageTask(cm, node, con)); factories.put(ClientRemovePartitionLostListenerCodec.REQUEST_MESSAGE_TYPE, (cm, con) -> new RemovePartitionLostListenerMessageTask(cm, node, con)); + factories.put(ClientAddMigrationListenerCodec.REQUEST_MESSAGE_TYPE, + (cm, con) -> new AddMigrationListenerMessageTask(cm, node, con)); + factories.put(ClientRemoveMigrationListenerCodec.REQUEST_MESSAGE_TYPE, + (cm, con) -> new RemoveMigrationListenerMessageTask(cm, node, con)); factories.put(ClientCreateProxyCodec.REQUEST_MESSAGE_TYPE, (cm, con) -> new CreateProxyMessageTask(cm, node, con)); factories.put(ClientGetDistributedObjectsCodec.REQUEST_MESSAGE_TYPE, diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java new file mode 100644 index 0000000000000..23f336abdf71a --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2008-2020, 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 com.hazelcast.logging.Logger; + +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. + */ + +/** + * Adds a Migration listener to the cluster. + */ +@Generated("45dae5149998b823955b8efceacb9dcf") +public final class ClientAddMigrationListenerCodec { + //hex: 0x001100 + public static final int REQUEST_MESSAGE_TYPE = 4352; + //hex: 0x001101 + public static final int RESPONSE_MESSAGE_TYPE = 4353; + private static final int REQUEST_LOCAL_ONLY_FIELD_OFFSET = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int REQUEST_INITIAL_FRAME_SIZE = REQUEST_LOCAL_ONLY_FIELD_OFFSET + BOOLEAN_SIZE_IN_BYTES; + private static final int RESPONSE_RESPONSE_FIELD_OFFSET = RESPONSE_BACKUP_ACKS_FIELD_OFFSET + BYTE_SIZE_IN_BYTES; + private static final int RESPONSE_INITIAL_FRAME_SIZE = RESPONSE_RESPONSE_FIELD_OFFSET + UUID_SIZE_IN_BYTES; + private static final int EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int EVENT_MIGRATION_INITIAL_FRAME_SIZE = EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + //hex: 0x001102 + private static final int EVENT_MIGRATION_MESSAGE_TYPE = 4354; + private static final int EVENT_REPLICA_MIGRATION_PARTITION_ID_FIELD_OFFSET = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int EVENT_REPLICA_MIGRATION_REPLICA_INDEX_FIELD_OFFSET = EVENT_REPLICA_MIGRATION_PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int EVENT_REPLICA_MIGRATION_SOURCE_UUID_FIELD_OFFSET = EVENT_REPLICA_MIGRATION_REPLICA_INDEX_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int EVENT_REPLICA_MIGRATION_DEST_UUID_FIELD_OFFSET = EVENT_REPLICA_MIGRATION_SOURCE_UUID_FIELD_OFFSET + UUID_SIZE_IN_BYTES; + private static final int EVENT_REPLICA_MIGRATION_SUCCESS_FIELD_OFFSET = EVENT_REPLICA_MIGRATION_DEST_UUID_FIELD_OFFSET + UUID_SIZE_IN_BYTES; + private static final int EVENT_REPLICA_MIGRATION_ELAPSED_TIME_FIELD_OFFSET = EVENT_REPLICA_MIGRATION_SUCCESS_FIELD_OFFSET + BOOLEAN_SIZE_IN_BYTES; + private static final int EVENT_REPLICA_MIGRATION_INITIAL_FRAME_SIZE = EVENT_REPLICA_MIGRATION_ELAPSED_TIME_FIELD_OFFSET + LONG_SIZE_IN_BYTES; + //hex: 0x001103 + private static final int EVENT_REPLICA_MIGRATION_MESSAGE_TYPE = 4355; + + private ClientAddMigrationListenerCodec() { + } + + public static ClientMessage encodeRequest(boolean localOnly) { + ClientMessage clientMessage = ClientMessage.createForEncode(); + clientMessage.setRetryable(false); + clientMessage.setOperationName("Client.AddMigrationListener"); + 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); + encodeBoolean(initialFrame.content, REQUEST_LOCAL_ONLY_FIELD_OFFSET, localOnly); + clientMessage.add(initialFrame); + return clientMessage; + } + + /** + * if true only node that has the migration sends the request, if false + * sends all partition lost events. + */ + public static boolean decodeRequest(ClientMessage clientMessage) { + ClientMessage.ForwardFrameIterator iterator = clientMessage.frameIterator(); + ClientMessage.Frame initialFrame = iterator.next(); + return decodeBoolean(initialFrame.content, REQUEST_LOCAL_ONLY_FIELD_OFFSET); + } + + public static ClientMessage encodeResponse(java.util.UUID response) { + 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); + encodeUUID(initialFrame.content, RESPONSE_RESPONSE_FIELD_OFFSET, response); + clientMessage.add(initialFrame); + + return clientMessage; + } + + /** + * The listener registration id. + */ + public static java.util.UUID decodeResponse(ClientMessage clientMessage) { + ClientMessage.ForwardFrameIterator iterator = clientMessage.frameIterator(); + ClientMessage.Frame initialFrame = iterator.next(); + return decodeUUID(initialFrame.content, RESPONSE_RESPONSE_FIELD_OFFSET); + } + + public static ClientMessage encodeMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId) { + ClientMessage clientMessage = ClientMessage.createForEncode(); + ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[EVENT_MIGRATION_INITIAL_FRAME_SIZE], UNFRAGMENTED_MESSAGE); + initialFrame.flags |= ClientMessage.IS_EVENT_FLAG; + encodeInt(initialFrame.content, TYPE_FIELD_OFFSET, EVENT_MIGRATION_MESSAGE_TYPE); + encodeInt(initialFrame.content, PARTITION_ID_FIELD_OFFSET, -1); + encodeInt(initialFrame.content, EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET, partitionId); + clientMessage.add(initialFrame); + + MigrationStateCodec.encode(clientMessage, migrationState); + return clientMessage; + } + public static ClientMessage encodeReplicaMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId, int replicaIndex, @Nullable java.util.UUID sourceUuid, @Nullable java.util.UUID destUuid, boolean success, long elapsedTime) { + ClientMessage clientMessage = ClientMessage.createForEncode(); + ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[EVENT_REPLICA_MIGRATION_INITIAL_FRAME_SIZE], UNFRAGMENTED_MESSAGE); + initialFrame.flags |= ClientMessage.IS_EVENT_FLAG; + encodeInt(initialFrame.content, TYPE_FIELD_OFFSET, EVENT_REPLICA_MIGRATION_MESSAGE_TYPE); + encodeInt(initialFrame.content, PARTITION_ID_FIELD_OFFSET, -1); + encodeInt(initialFrame.content, EVENT_REPLICA_MIGRATION_PARTITION_ID_FIELD_OFFSET, partitionId); + encodeInt(initialFrame.content, EVENT_REPLICA_MIGRATION_REPLICA_INDEX_FIELD_OFFSET, replicaIndex); + encodeUUID(initialFrame.content, EVENT_REPLICA_MIGRATION_SOURCE_UUID_FIELD_OFFSET, sourceUuid); + encodeUUID(initialFrame.content, EVENT_REPLICA_MIGRATION_DEST_UUID_FIELD_OFFSET, destUuid); + encodeBoolean(initialFrame.content, EVENT_REPLICA_MIGRATION_SUCCESS_FIELD_OFFSET, success); + encodeLong(initialFrame.content, EVENT_REPLICA_MIGRATION_ELAPSED_TIME_FIELD_OFFSET, elapsedTime); + clientMessage.add(initialFrame); + + MigrationStateCodec.encode(clientMessage, migrationState); + return clientMessage; + } + + public abstract static class AbstractEventHandler { + + public void handle(ClientMessage clientMessage) { + int messageType = clientMessage.getMessageType(); + ClientMessage.ForwardFrameIterator iterator = clientMessage.frameIterator(); + if (messageType == EVENT_MIGRATION_MESSAGE_TYPE) { + ClientMessage.Frame initialFrame = iterator.next(); + int partitionId = decodeInt(initialFrame.content, EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET); + com.hazelcast.partition.MigrationState migrationState = MigrationStateCodec.decode(iterator); + handleMigrationEvent(migrationState, partitionId); + return; + } + if (messageType == EVENT_REPLICA_MIGRATION_MESSAGE_TYPE) { + ClientMessage.Frame initialFrame = iterator.next(); + int partitionId = decodeInt(initialFrame.content, EVENT_REPLICA_MIGRATION_PARTITION_ID_FIELD_OFFSET); + int replicaIndex = decodeInt(initialFrame.content, EVENT_REPLICA_MIGRATION_REPLICA_INDEX_FIELD_OFFSET); + java.util.UUID sourceUuid = decodeUUID(initialFrame.content, EVENT_REPLICA_MIGRATION_SOURCE_UUID_FIELD_OFFSET); + java.util.UUID destUuid = decodeUUID(initialFrame.content, EVENT_REPLICA_MIGRATION_DEST_UUID_FIELD_OFFSET); + boolean success = decodeBoolean(initialFrame.content, EVENT_REPLICA_MIGRATION_SUCCESS_FIELD_OFFSET); + long elapsedTime = decodeLong(initialFrame.content, EVENT_REPLICA_MIGRATION_ELAPSED_TIME_FIELD_OFFSET); + com.hazelcast.partition.MigrationState migrationState = MigrationStateCodec.decode(iterator); + handleReplicaMigrationEvent(migrationState, partitionId, replicaIndex, sourceUuid, destUuid, success, elapsedTime); + return; + } + Logger.getLogger(super.getClass()).finest("Unknown message type received on event handler :" + messageType); + } + + /** + * @param migrationState Migration state. + * @param partitionId The id assigned during the listener registration. + */ + public abstract void handleMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId); + + /** + * @param migrationState The progress information of the overall migration. + * @param partitionId The partition ID that the event is dispatched for. + * @param replicaIndex The index of the partition replica. + * @param sourceUuid The id of old owner of the migrating partition replica. + * @param destUuid The id of new owner of the migrating partition replica. + * @param success The result of the migration: completed or failed. + * @param elapsedTime The elapsed the time of this migration in milliseconds. + */ + public abstract void handleReplicaMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId, int replicaIndex, @Nullable java.util.UUID sourceUuid, @Nullable java.util.UUID destUuid, boolean success, long elapsedTime); + } +} diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientRemoveMigrationListenerCodec.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientRemoveMigrationListenerCodec.java new file mode 100644 index 0000000000000..afad8d45db414 --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientRemoveMigrationListenerCodec.java @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2008-2020, 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. + */ + +/** + * Removes a Migration listener to the cluster. + */ +@Generated("4fdf5557dc61841bc7b060851b6c8d5d") +public final class ClientRemoveMigrationListenerCodec { + //hex: 0x001200 + public static final int REQUEST_MESSAGE_TYPE = 4608; + //hex: 0x001201 + public static final int RESPONSE_MESSAGE_TYPE = 4609; + private static final int REQUEST_REGISTRATION_ID_FIELD_OFFSET = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int REQUEST_INITIAL_FRAME_SIZE = REQUEST_REGISTRATION_ID_FIELD_OFFSET + UUID_SIZE_IN_BYTES; + private static final int RESPONSE_RESPONSE_FIELD_OFFSET = RESPONSE_BACKUP_ACKS_FIELD_OFFSET + BYTE_SIZE_IN_BYTES; + private static final int RESPONSE_INITIAL_FRAME_SIZE = RESPONSE_RESPONSE_FIELD_OFFSET + BOOLEAN_SIZE_IN_BYTES; + + private ClientRemoveMigrationListenerCodec() { + } + + public static ClientMessage encodeRequest(java.util.UUID registrationId) { + ClientMessage clientMessage = ClientMessage.createForEncode(); + clientMessage.setRetryable(true); + clientMessage.setOperationName("Client.RemoveMigrationListener"); + 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); + encodeUUID(initialFrame.content, REQUEST_REGISTRATION_ID_FIELD_OFFSET, registrationId); + clientMessage.add(initialFrame); + return clientMessage; + } + + /** + * The id assigned during the listener registration. + */ + public static java.util.UUID decodeRequest(ClientMessage clientMessage) { + ClientMessage.ForwardFrameIterator iterator = clientMessage.frameIterator(); + ClientMessage.Frame initialFrame = iterator.next(); + return decodeUUID(initialFrame.content, REQUEST_REGISTRATION_ID_FIELD_OFFSET); + } + + public static ClientMessage encodeResponse(boolean response) { + 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); + encodeBoolean(initialFrame.content, RESPONSE_RESPONSE_FIELD_OFFSET, response); + clientMessage.add(initialFrame); + + return clientMessage; + } + + /** + * true if the listener existed and removed, false otherwise. + */ + public static boolean decodeResponse(ClientMessage clientMessage) { + ClientMessage.ForwardFrameIterator iterator = clientMessage.frameIterator(); + ClientMessage.Frame initialFrame = iterator.next(); + return decodeBoolean(initialFrame.content, RESPONSE_RESPONSE_FIELD_OFFSET); + } + +} diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/custom/MigrationStateCodec.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/custom/MigrationStateCodec.java new file mode 100644 index 0000000000000..278856bbfaa28 --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/custom/MigrationStateCodec.java @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2008-2020, 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.custom; + +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.Generated; +import com.hazelcast.client.impl.protocol.codec.builtin.*; + +import static com.hazelcast.client.impl.protocol.codec.builtin.CodecUtil.fastForwardToEndFrame; +import static com.hazelcast.client.impl.protocol.ClientMessage.*; +import static com.hazelcast.client.impl.protocol.codec.builtin.FixedSizeTypesCodec.*; + +@Generated("8743b8f5be8de8613841b3b4cbae50a6") +public final class MigrationStateCodec { + private static final int START_TIME_FIELD_OFFSET = 0; + private static final int PLANNED_MIGRATIONS_FIELD_OFFSET = START_TIME_FIELD_OFFSET + LONG_SIZE_IN_BYTES; + private static final int COMPLETED_MIGRATIONS_FIELD_OFFSET = PLANNED_MIGRATIONS_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int TOTAL_ELAPSED_TIME_FIELD_OFFSET = COMPLETED_MIGRATIONS_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int INITIAL_FRAME_SIZE = TOTAL_ELAPSED_TIME_FIELD_OFFSET + LONG_SIZE_IN_BYTES; + + private MigrationStateCodec() { + } + + public static void encode(ClientMessage clientMessage, com.hazelcast.partition.MigrationState migrationState) { + clientMessage.add(BEGIN_FRAME.copy()); + + ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[INITIAL_FRAME_SIZE]); + encodeLong(initialFrame.content, START_TIME_FIELD_OFFSET, migrationState.getStartTime()); + encodeInt(initialFrame.content, PLANNED_MIGRATIONS_FIELD_OFFSET, migrationState.getPlannedMigrations()); + encodeInt(initialFrame.content, COMPLETED_MIGRATIONS_FIELD_OFFSET, migrationState.getCompletedMigrations()); + encodeLong(initialFrame.content, TOTAL_ELAPSED_TIME_FIELD_OFFSET, migrationState.getTotalElapsedTime()); + clientMessage.add(initialFrame); + + clientMessage.add(END_FRAME.copy()); + } + + public static com.hazelcast.internal.partition.MigrationStateImpl decode(ClientMessage.ForwardFrameIterator iterator) { + // begin frame + iterator.next(); + + ClientMessage.Frame initialFrame = iterator.next(); + long startTime = decodeLong(initialFrame.content, START_TIME_FIELD_OFFSET); + int plannedMigrations = decodeInt(initialFrame.content, PLANNED_MIGRATIONS_FIELD_OFFSET); + int completedMigrations = decodeInt(initialFrame.content, COMPLETED_MIGRATIONS_FIELD_OFFSET); + long totalElapsedTime = decodeLong(initialFrame.content, TOTAL_ELAPSED_TIME_FIELD_OFFSET); + + fastForwardToEndFrame(iterator); + + return new com.hazelcast.internal.partition.MigrationStateImpl(startTime, plannedMigrations, completedMigrations, totalElapsedTime); + } +} diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java new file mode 100644 index 0000000000000..a555a4f7eda69 --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2008-2020, 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; + +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.codec.ClientAddMigrationListenerCodec; +import com.hazelcast.instance.impl.Node; +import com.hazelcast.internal.nio.Connection; +import com.hazelcast.internal.partition.IPartitionService; +import com.hazelcast.partition.MigrationListener; +import com.hazelcast.partition.MigrationState; +import com.hazelcast.internal.partition.MigrationStateImpl; +import com.hazelcast.partition.ReplicaMigrationEvent; + +import java.security.Permission; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; + +import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; +import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED; +import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED; +import static com.hazelcast.spi.impl.InternalCompletableFuture.newCompletedFuture; + +public class AddMigrationListenerMessageTask + extends AbstractAddListenerMessageTask { + + public AddMigrationListenerMessageTask(ClientMessage clientMessage, Node node, Connection connection) { + super(clientMessage, node, connection); + } + + @Override + protected CompletableFuture processInternal() { + final IPartitionService partitionService = getService(getServiceName()); + + + final MigrationListener listener = new MigrationListener() { + + @Override + public void migrationStarted(MigrationState state) { + sendIfAlive(encodeMigrationEvent(state, MIGRATION_STARTED)); + } + + @Override + public void migrationFinished(MigrationState state) { + sendIfAlive(encodeMigrationEvent(state, MIGRATION_FINISHED)); + } + + @Override + public void replicaMigrationCompleted(ReplicaMigrationEvent event) { + sendIfAlive(encodeReplicaMigrationEvent(event)); + } + + @Override + public void replicaMigrationFailed(ReplicaMigrationEvent event) { + sendIfAlive(encodeReplicaMigrationEvent(event)); + } + }; + + if (parameters) { + return newCompletedFuture(partitionService.addLocalMigrationListener(listener)); + } + + return partitionService.addMigrationListenerAsync(listener); + } + + private void sendIfAlive(ClientMessage eventMessage) { + if (endpoint.isAlive()) { + sendClientMessage(null, eventMessage); + } + } + + private ClientMessage encodeReplicaMigrationEvent(ReplicaMigrationEvent event) { + return ClientAddMigrationListenerCodec.encodeReplicaMigrationEvent( + new MigrationStateImpl( + event.getMigrationState().getStartTime(), + event.getMigrationState().getPlannedMigrations(), + event.getMigrationState().getCompletedMigrations(), + event.getMigrationState().getTotalElapsedTime() + ), + event.getPartitionId(), + event.getReplicaIndex(), + event.getSource() != null ? event.getSource().getUuid() : null, + event.getDestination() != null ? event.getDestination().getUuid() : null, + event.isSuccess(), + event.getElapsedTime() + ); + } + + private ClientMessage encodeMigrationEvent(MigrationState event, int partitionId) { + return ClientAddMigrationListenerCodec.encodeMigrationEvent( + new MigrationStateImpl( + event.getStartTime(), + event.getPlannedMigrations(), + event.getCompletedMigrations(), + event.getTotalElapsedTime() + ), + partitionId + ); + } + + @Override + protected Boolean decodeClientMessage(ClientMessage clientMessage) { + return ClientAddMigrationListenerCodec.decodeRequest(clientMessage); + } + + @Override + protected ClientMessage encodeResponse(Object response) { + return ClientAddMigrationListenerCodec.encodeResponse((UUID) response); + } + + @Override + public String getServiceName() { + return IPartitionService.SERVICE_NAME; + } + + @Override + public Permission getRequiredPermission() { + return null; + } + + @Override + public String getDistributedObjectName() { + return MIGRATION_EVENT_TOPIC; + } + + @Override + public String getMethodName() { + return "addMigrationListener"; + } + + @Override + public Object[] getParameters() { + return null; + } +} diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java new file mode 100644 index 0000000000000..ec05dea715957 --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2008-2020, 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; + +import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.codec.ClientRemoveMigrationListenerCodec; +import com.hazelcast.instance.impl.Node; +import com.hazelcast.internal.nio.Connection; +import com.hazelcast.internal.partition.InternalPartitionService; + +import java.security.Permission; +import java.util.UUID; +import java.util.concurrent.Future; + +public class RemoveMigrationListenerMessageTask + extends AbstractRemoveListenerMessageTask { + + public RemoveMigrationListenerMessageTask(ClientMessage clientMessage, Node node, Connection connection) { + super(clientMessage, node, connection); + } + + @Override + protected Future deRegisterListener() { + final InternalPartitionService service = getService(InternalPartitionService.SERVICE_NAME); + return service.removeMigrationListenerAsync(parameters); + } + + @Override + protected UUID getRegistrationId() { + return parameters; + } + + @Override + protected UUID decodeClientMessage(ClientMessage clientMessage) { + return ClientRemoveMigrationListenerCodec.decodeRequest(clientMessage); + } + + @Override + protected ClientMessage encodeResponse(Object response) { + return ClientRemoveMigrationListenerCodec.encodeResponse((Boolean) response); + } + + @Override + public String getServiceName() { + return InternalPartitionService.SERVICE_NAME; + } + + @Override + public Permission getRequiredPermission() { + return null; + } + + @Override + public String getDistributedObjectName() { + return null; + } + + @Override + public String getMethodName() { + return "removeMigrationListener"; + } + +} diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java index 32c0cbba9a2c2..125142704d7e1 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java @@ -17,7 +17,9 @@ package com.hazelcast.client.impl.proxy; import com.hazelcast.client.impl.protocol.ClientMessage; +import com.hazelcast.client.impl.protocol.codec.ClientAddMigrationListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientAddPartitionLostListenerCodec; +import com.hazelcast.client.impl.protocol.codec.ClientRemoveMigrationListenerCodec; import com.hazelcast.client.impl.protocol.codec.ClientRemovePartitionLostListenerCodec; import com.hazelcast.client.impl.spi.ClientClusterService; import com.hazelcast.client.impl.spi.ClientListenerService; @@ -26,12 +28,17 @@ import com.hazelcast.client.impl.spi.impl.ListenerMessageCodec; import com.hazelcast.cluster.Member; import com.hazelcast.internal.partition.PartitionLostEventImpl; +import com.hazelcast.internal.partition.MigrationEventHandler; +import com.hazelcast.internal.partition.ReplicaMigrationEventImpl; import com.hazelcast.partition.MigrationListener; +import com.hazelcast.partition.MigrationState; import com.hazelcast.partition.Partition; import com.hazelcast.partition.PartitionLostListener; import com.hazelcast.partition.PartitionService; +import com.hazelcast.partition.ReplicaMigrationEvent; import javax.annotation.Nonnull; +import javax.annotation.Nullable; import java.util.LinkedHashSet; import java.util.Set; import java.util.UUID; @@ -58,7 +65,7 @@ public PartitionServiceProxy(ClientPartitionService partitionService, @Override public Set getPartitions() { final int partitionCount = partitionService.getPartitionCount(); - Set partitions = new LinkedHashSet(partitionCount); + Set partitions = new LinkedHashSet<>(partitionCount); for (int i = 0; i < partitionCount; i++) { final Partition partition = partitionService.getPartition(i); partitions.add(partition); @@ -75,12 +82,13 @@ public Partition getPartition(@Nonnull Object key) { @Override public UUID addMigrationListener(MigrationListener migrationListener) { - throw new UnsupportedOperationException(); + EventHandler handler = new ClientMigrationEventHandler(migrationListener); + return listenerService.registerListener(createMigrationListenerCodec(), handler); } @Override public boolean removeMigrationListener(UUID registrationId) { - throw new UnsupportedOperationException(); + return listenerService.deregisterListener(registrationId); } @Override @@ -113,6 +121,30 @@ public boolean decodeRemoveResponse(ClientMessage clientMessage) { }; } + private ListenerMessageCodec createMigrationListenerCodec() { + return new ListenerMessageCodec() { + @Override + public ClientMessage encodeAddRequest(boolean localOnly) { + return ClientAddMigrationListenerCodec.encodeRequest(localOnly); + } + + @Override + public UUID decodeAddResponse(ClientMessage clientMessage) { + return ClientAddMigrationListenerCodec.decodeResponse(clientMessage); + } + + @Override + public ClientMessage encodeRemoveRequest(UUID realRegistrationId) { + return ClientRemoveMigrationListenerCodec.encodeRequest(realRegistrationId); + } + + @Override + public boolean decodeRemoveResponse(ClientMessage clientMessage) { + return ClientRemoveMigrationListenerCodec.decodeResponse(clientMessage); + } + }; + } + @Override public boolean removePartitionLostListener(UUID registrationId) { return listenerService.deregisterListener(registrationId); @@ -141,7 +173,7 @@ public boolean forceLocalMemberToBeSafe(long timeout, TimeUnit unit) { private class ClientPartitionLostEventHandler extends ClientAddPartitionLostListenerCodec.AbstractEventHandler implements EventHandler { - private PartitionLostListener listener; + private final PartitionLostListener listener; ClientPartitionLostEventHandler(PartitionLostListener listener) { this.listener = listener; @@ -154,4 +186,37 @@ public void handlePartitionLostEvent(int partitionId, int lostBackupCount, UUID } } + private class ClientMigrationEventHandler extends ClientAddMigrationListenerCodec.AbstractEventHandler + implements EventHandler { + + private final MigrationEventHandler migrationEventHandler; + + ClientMigrationEventHandler(MigrationListener listener) { + this.migrationEventHandler = new MigrationEventHandler(listener); + } + + + @Override + public void handleMigrationEvent(MigrationState migrationState, int partitionId) { + migrationEventHandler.handleMigrationState(migrationState, partitionId); + } + + @Override + public void handleReplicaMigrationEvent(MigrationState migrationState, + int partitionId, + int replicaIndex, + @Nullable UUID sourceUuid, + @Nullable UUID destUuid, + boolean success, + long elapsedTime) { + + Member source = sourceUuid != null ? clusterService.getMember(sourceUuid) : null; + Member destination = destUuid != null ? clusterService.getMember(destUuid) : null; + + ReplicaMigrationEvent event = new ReplicaMigrationEventImpl(migrationState, partitionId, + replicaIndex, source, destination, success, elapsedTime); + + migrationEventHandler.handleReplicaMigration(event); + } + } } diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java b/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java index 9016bc6b85428..6c2d098aff432 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java @@ -55,5 +55,4 @@ public interface ClientPartitionService { int getPartitionCount(); Partition getPartition(int partitionId); - } diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java index 46a9592e01e03..6d40cff07f36e 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java @@ -131,14 +131,20 @@ public interface IPartitionService extends CoreService { UUID addMigrationListener(MigrationListener migrationListener); + CompletableFuture addMigrationListenerAsync(MigrationListener migrationListener); + boolean removeMigrationListener(UUID registrationId); + CompletableFuture removeMigrationListenerAsync(UUID registrationId); + UUID addPartitionLostListener(PartitionLostListener partitionLostListener); CompletableFuture addPartitionLostListenerAsync(PartitionLostListener partitionLostListener); UUID addLocalPartitionLostListener(PartitionLostListener partitionLostListener); + UUID addLocalMigrationListener(MigrationListener migrationListener); + boolean removePartitionLostListener(UUID registrationId); CompletableFuture removePartitionLostListenerAsync(UUID registrationId); diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java new file mode 100644 index 0000000000000..a1f2613b47656 --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2008-2020, 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.internal.partition; + +import com.hazelcast.partition.MigrationListener; +import com.hazelcast.partition.MigrationState; +import com.hazelcast.partition.ReplicaMigrationEvent; + +public final class MigrationEventHandler { + + public static final int MIGRATION_STARTED = -1; + public static final int MIGRATION_FINISHED = -2; + + private final MigrationListener migrationListener; + + public MigrationEventHandler(MigrationListener migrationListener) { + this.migrationListener = migrationListener; + } + + public void handleMigrationState(MigrationState state, int partitionId) { + switch (partitionId) { + case MIGRATION_STARTED: + migrationListener.migrationStarted(state); + break; + case MIGRATION_FINISHED: + migrationListener.migrationFinished(state); + break; + default: + break; + } + } + + public void handleReplicaMigration(ReplicaMigrationEvent event) { + switch (event.getPartitionId()) { + case MIGRATION_STARTED: + case MIGRATION_FINISHED: + handleMigrationState(event.getMigrationState(), event.getPartitionId()); + break; + default: + if (event.isSuccess()) { + migrationListener.replicaMigrationCompleted(event); + } else { + migrationListener.replicaMigrationFailed(event); + } + } + } +} diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationStateImpl.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationStateImpl.java index c75379fb41d7f..b15aa0ac77ed2 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationStateImpl.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationStateImpl.java @@ -23,6 +23,7 @@ import com.hazelcast.partition.MigrationState; import java.io.IOException; +import java.util.Objects; /** * Summary of the migration state. @@ -109,4 +110,24 @@ public String toString() { return "MigrationState{startTime=" + startTime + ", plannedMigrations=" + plannedMigrations + ", completedMigrations=" + completedMigrations + ", totalElapsedTime=" + totalElapsedTime + "ms}"; } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof MigrationStateImpl)) { + return false; + } + MigrationStateImpl that = (MigrationStateImpl) o; + return startTime == that.startTime + && plannedMigrations == that.plannedMigrations + && completedMigrations == that.completedMigrations + && totalElapsedTime == that.totalElapsedTime; + } + + @Override + public int hashCode() { + return Objects.hash(startTime, plannedMigrations, completedMigrations, totalElapsedTime); + } } diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java index ab9ed8cf91964..e770c522f1c76 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java @@ -1228,11 +1228,26 @@ public UUID addMigrationListener(MigrationListener listener) { return partitionEventManager.addMigrationListener(listener); } + @Override + public UUID addLocalMigrationListener(MigrationListener migrationListener) { + return partitionEventManager.addLocalMigrationListener(migrationListener); + } + @Override public boolean removeMigrationListener(UUID registrationId) { return partitionEventManager.removeMigrationListener(registrationId); } + @Override + public CompletableFuture addMigrationListenerAsync(MigrationListener migrationListener) { + return partitionEventManager.addMigrationListenerAsync(migrationListener); + } + + @Override + public CompletableFuture removeMigrationListenerAsync(UUID registrationId) { + return partitionEventManager.removeMigrationListenerAsync(registrationId); + } + @Override public UUID addPartitionLostListener(PartitionLostListener listener) { return partitionEventManager.addPartitionLostListener(listener); diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java index 51689d9b294b1..28b7d69563817 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java @@ -17,6 +17,7 @@ package com.hazelcast.internal.partition.impl; import com.hazelcast.internal.partition.PartitionEventListener; +import com.hazelcast.internal.partition.MigrationEventHandler; import com.hazelcast.partition.ReplicaMigrationEvent; import com.hazelcast.partition.MigrationListener; @@ -25,33 +26,15 @@ */ class MigrationListenerAdapter implements PartitionEventListener { - static final int MIGRATION_STARTED = -1; - static final int MIGRATION_FINISHED = -2; - - private final MigrationListener migrationListener; + private final MigrationEventHandler migrationEventHandler; MigrationListenerAdapter(MigrationListener migrationListener) { - this.migrationListener = migrationListener; + this.migrationEventHandler = new MigrationEventHandler(migrationListener); } @Override public void onEvent(ReplicaMigrationEvent event) { - - switch (event.getPartitionId()) { - case MIGRATION_STARTED: - migrationListener.migrationStarted(event.getMigrationState()); - break; - case MIGRATION_FINISHED: - migrationListener.migrationFinished(event.getMigrationState()); - break; - default: - if (event.isSuccess()) { - migrationListener.replicaMigrationCompleted(event); - } else { - migrationListener.replicaMigrationFailed(event); - } - } - + migrationEventHandler.handleReplicaMigration(event); } } diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java index 2e14e654d6d2d..3ada36a292026 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java @@ -23,6 +23,7 @@ import com.hazelcast.internal.partition.MigrationInfo; import com.hazelcast.internal.partition.MigrationInfo.MigrationStatus; import com.hazelcast.internal.partition.PartitionAwareService; +import com.hazelcast.internal.partition.PartitionEventListener; import com.hazelcast.internal.partition.PartitionLostEventImpl; import com.hazelcast.internal.partition.PartitionReplica; import com.hazelcast.internal.partition.ReplicaMigrationEventImpl; @@ -36,6 +37,7 @@ import com.hazelcast.spi.impl.eventservice.EventRegistration; import com.hazelcast.spi.impl.eventservice.EventService; +import javax.annotation.Nonnull; import java.util.Collection; import java.util.UUID; import java.util.concurrent.CompletableFuture; @@ -43,9 +45,10 @@ import static com.hazelcast.internal.partition.IPartitionService.SERVICE_NAME; import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; import static com.hazelcast.internal.partition.InternalPartitionService.PARTITION_LOST_EVENT_TOPIC; -import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_FINISHED; -import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_STARTED; +import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED; +import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED; import static com.hazelcast.internal.util.ConcurrencyUtil.CALLER_RUNS; +import static com.hazelcast.internal.util.Preconditions.checkNotNull; import static com.hazelcast.spi.impl.executionservice.ExecutionService.SYSTEM_EXECUTOR; /** @@ -94,10 +97,8 @@ private void sendMigrationEvent(ReplicaMigrationEvent event) { eventService.publishEvent(SERVICE_NAME, MIGRATION_EVENT_TOPIC, event, MIGRATION_EVENT_TOPIC.hashCode()); } - public UUID addMigrationListener(MigrationListener listener) { - if (listener == null) { - throw new NullPointerException("listener can't be null"); - } + public UUID addMigrationListener(@Nonnull MigrationListener listener) { + checkNotNull(listener, "listener can't be null"); final MigrationListenerAdapter adapter = new MigrationListenerAdapter(listener); @@ -106,19 +107,42 @@ public UUID addMigrationListener(MigrationListener listener) { return registration.getId(); } - public boolean removeMigrationListener(UUID registrationId) { - if (registrationId == null) { - throw new NullPointerException("registrationId can't be null"); - } + public UUID addLocalMigrationListener(@Nonnull MigrationListener listener) { + checkNotNull(listener, "listener can't be null"); + + final MigrationListenerAdapter adapter = new MigrationListenerAdapter(listener); + + return registerLocalListener(adapter, MIGRATION_EVENT_TOPIC); + } + + public CompletableFuture addMigrationListenerAsync(@Nonnull MigrationListener listener) { + checkNotNull(listener, "listener can't be null"); + + final MigrationListenerAdapter adapter = new MigrationListenerAdapter(listener); EventService eventService = nodeEngine.getEventService(); + return eventService.registerListenerAsync(SERVICE_NAME, MIGRATION_EVENT_TOPIC, adapter) + .thenApplyAsync(EventRegistration::getId, CALLER_RUNS); + } + + public boolean removeMigrationListener(@Nonnull UUID registrationId) { + checkNotNull(registrationId, "registrationId can't be null"); + + EventService eventService = nodeEngine.getEventService(); + return eventService.deregisterListener(SERVICE_NAME, MIGRATION_EVENT_TOPIC, registrationId); } - public UUID addPartitionLostListener(PartitionLostListener listener) { - if (listener == null) { - throw new NullPointerException("listener can't be null"); - } + public CompletableFuture removeMigrationListenerAsync(@Nonnull UUID registrationId) { + checkNotNull(registrationId, "registrationId can't be null"); + + EventService eventService = nodeEngine.getEventService(); + + return eventService.deregisterListenerAsync(SERVICE_NAME, MIGRATION_EVENT_TOPIC, registrationId); + } + + public UUID addPartitionLostListener(@Nonnull PartitionLostListener listener) { + checkNotNull(listener, "listener can't be null"); final PartitionLostListenerAdapter adapter = new PartitionLostListenerAdapter(listener); @@ -127,45 +151,31 @@ public UUID addPartitionLostListener(PartitionLostListener listener) { return registration.getId(); } - public CompletableFuture addPartitionLostListenerAsync(PartitionLostListener listener) { - if (listener == null) { - throw new NullPointerException("listener can't be null"); - } + public CompletableFuture addPartitionLostListenerAsync(@Nonnull PartitionLostListener listener) { + checkNotNull(listener, "listener can't be null"); final PartitionLostListenerAdapter adapter = new PartitionLostListenerAdapter(listener); - EventService eventService = nodeEngine.getEventService(); return eventService.registerListenerAsync(SERVICE_NAME, PARTITION_LOST_EVENT_TOPIC, adapter) .thenApplyAsync(EventRegistration::getId, CALLER_RUNS); } - public UUID addLocalPartitionLostListener(PartitionLostListener listener) { - if (listener == null) { - throw new NullPointerException("listener can't be null"); - } + public UUID addLocalPartitionLostListener(@Nonnull PartitionLostListener listener) { + checkNotNull(listener, "listener can't be null"); final PartitionLostListenerAdapter adapter = new PartitionLostListenerAdapter(listener); - EventService eventService = nodeEngine.getEventService(); - EventRegistration registration = - eventService.registerLocalListener(SERVICE_NAME, PARTITION_LOST_EVENT_TOPIC, adapter); - return registration.getId(); + return registerLocalListener(adapter, PARTITION_LOST_EVENT_TOPIC); } - public boolean removePartitionLostListener(UUID registrationId) { - if (registrationId == null) { - throw new NullPointerException("registrationId can't be null"); - } - + public boolean removePartitionLostListener(@Nonnull UUID registrationId) { + checkNotNull(registrationId, "registrationId can't be null"); EventService eventService = nodeEngine.getEventService(); return eventService.deregisterListener(SERVICE_NAME, PARTITION_LOST_EVENT_TOPIC, registrationId); } public CompletableFuture removePartitionLostListenerAsync(UUID registrationId) { - if (registrationId == null) { - throw new NullPointerException("registrationId can't be null"); - } - + checkNotNull(registrationId, "registrationId can't be null"); EventService eventService = nodeEngine.getEventService(); return eventService.deregisterListenerAsync(SERVICE_NAME, PARTITION_LOST_EVENT_TOPIC, registrationId); } @@ -185,6 +195,13 @@ public void sendPartitionLostEvent(int partitionId, int lostReplicaIndex) { nodeEngine.getExecutionService().execute(SYSTEM_EXECUTOR, publisher); } + private UUID registerLocalListener(PartitionEventListener adapter, String topic) { + EventService eventService = nodeEngine.getEventService(); + EventRegistration registration = + eventService.registerLocalListener(SERVICE_NAME, topic, adapter); + return registration.getId(); + } + /** Task which notifies all {@link PartitionAwareService}s that replicas have been lost. */ private static class InternalPartitionLostEventPublisher implements Runnable { diff --git a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java new file mode 100644 index 0000000000000..406a7502c2294 --- /dev/null +++ b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java @@ -0,0 +1,232 @@ +/* + * Copyright (c) 2008-2020, 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.partitionservice; + +import com.hazelcast.client.config.ClientConfig; +import com.hazelcast.client.test.TestHazelcastFactory; +import com.hazelcast.cluster.ClusterState; +import com.hazelcast.config.Config; +import com.hazelcast.config.ListenerConfig; +import com.hazelcast.core.HazelcastInstance; +import com.hazelcast.internal.util.UuidUtil; +import com.hazelcast.partition.MigrationListener; +import com.hazelcast.internal.partition.MigrationStateImpl; +import com.hazelcast.partition.PartitionMigrationListenerTest; +import com.hazelcast.partition.PartitionService; +import com.hazelcast.partition.ReplicaMigrationEvent; +import com.hazelcast.spi.impl.eventservice.EventRegistration; +import com.hazelcast.spi.impl.eventservice.EventService; +import com.hazelcast.spi.properties.ClusterProperty; +import com.hazelcast.test.HazelcastParallelClassRunner; +import com.hazelcast.test.annotation.ParallelJVMTest; +import com.hazelcast.test.annotation.QuickTest; +import org.hamcrest.Matchers; +import org.junit.After; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; + +import java.util.Collection; +import java.util.UUID; +import java.util.concurrent.atomic.AtomicInteger; + +import static com.hazelcast.internal.cluster.impl.AdvancedClusterStateTest.changeClusterStateEventually; +import static com.hazelcast.internal.partition.IPartitionService.SERVICE_NAME; +import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; +import static com.hazelcast.partition.PartitionMigrationListenerTest.assertMigrationEventsConsistentWithResult; +import static com.hazelcast.partition.PartitionMigrationListenerTest.assertMigrationProcessCompleted; +import static com.hazelcast.partition.PartitionMigrationListenerTest.assertMigrationProcessEventsConsistent; +import static com.hazelcast.test.Accessors.getNode; +import static com.hazelcast.test.HazelcastTestSupport.assertTrueEventually; +import static com.hazelcast.test.HazelcastTestSupport.waitAllForSafeState; +import static com.hazelcast.test.HazelcastTestSupport.warmUpPartitions; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; + +@RunWith(HazelcastParallelClassRunner.class) +@Category({QuickTest.class, ParallelJVMTest.class}) +public class ClientMigrationListenerTest { + + private final TestHazelcastFactory hazelcastFactory = new TestHazelcastFactory(); + + @After + public void tearDown() { + hazelcastFactory.terminateAll(); + } + + @Test + public void testAddMigrationListener_whenRegisteredByConfig() { + HazelcastInstance instance = hazelcastFactory.newHazelcastInstance(); + ClientConfig clientConfig = new ClientConfig().addListenerConfig(new ListenerConfig(mock(MigrationListener.class))); + + hazelcastFactory.newHazelcastClient(clientConfig); + + assertRegistrationsSizeEventually(instance, 1); + } + + @Test + public void testAddMigrationListener_whenRegisteredByPartitionService() { + HazelcastInstance instance = hazelcastFactory.newHazelcastInstance(); + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + + client.getPartitionService().addMigrationListener(mock(MigrationListener.class)); + + assertRegistrationsSizeEventually(instance, 1); + } + + @Test + public void testAddMigrationListener_whenListenerRegisteredTwice() { + hazelcastFactory.newHazelcastInstance(); + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + PartitionService partitionService = client.getPartitionService(); + MigrationListener listener = mock(MigrationListener.class); + + UUID id1 = partitionService.addMigrationListener(listener); + UUID id2 = partitionService.addMigrationListener(listener); + + assertNotEquals(id1, id2); + } + + @Test(expected = NullPointerException.class) + public void testRemoveMigrationListener_whenNullListener() { + hazelcastFactory.newHazelcastInstance(); + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + PartitionService partitionService = client.getPartitionService(); + + partitionService.removeMigrationListener(null); + } + + @Test + public void testRemoveMigrationListener_whenNonExistingRegistrationId() { + hazelcastFactory.newHazelcastInstance(); + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + PartitionService partitionService = client.getPartitionService(); + + boolean result = partitionService.removeMigrationListener(UuidUtil.newUnsecureUUID()); + + assertFalse(result); + } + + @Test + public void testRemoveMigrationListener() { + HazelcastInstance instance = hazelcastFactory.newHazelcastInstance(); + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + PartitionService clientPartitionService = client.getPartitionService(); + MigrationListener listener = mock(MigrationListener.class); + + UUID registrationId = clientPartitionService.addMigrationListener(listener); + assertRegistrationsSizeEventually(instance, 1); + + boolean removed = clientPartitionService.removeMigrationListener(registrationId); + assertRegistrationsSizeEventually(instance, 0); + + assertTrue(removed); + + HazelcastInstance hz2 = hazelcastFactory.newHazelcastInstance(); + warmUpPartitions(instance, hz2); + + verify(listener, never()).migrationStarted(any(MigrationStateImpl.class)); + verify(listener, never()).replicaMigrationCompleted(any(ReplicaMigrationEvent.class)); + } + + @Test + public void testMigrationListenerCalledOnlyOnceWhenMigrationHappens() { + Config config = new Config(); + // even partition count to make migration count deterministic + int partitionCount = 10; + config.setProperty(ClusterProperty.PARTITION_COUNT.getName(), String.valueOf(partitionCount)); + + HazelcastInstance instance1 = hazelcastFactory.newHazelcastInstance(config); + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + warmUpPartitions(instance1); + + // Change to NO_MIGRATION to prevent repartitioning + // before 2nd member started and ready. + instance1.getCluster().changeClusterState(ClusterState.NO_MIGRATION); + + PartitionMigrationListenerTest.CountingMigrationListener migrationListener = new PartitionMigrationListenerTest.CountingMigrationListener(partitionCount); + client.getPartitionService().addMigrationListener(migrationListener); + + HazelcastInstance instance2 = hazelcastFactory.newHazelcastInstance(config); + + changeClusterStateEventually(instance2, ClusterState.ACTIVE); + + waitAllForSafeState(instance2, instance1); + + assertTrueEventually(() -> { + assertEquals(1, migrationListener.migrationStarted.get()); + assertEquals(1, migrationListener.migrationCompleted.get()); + + int completed = getTotal(migrationListener.replicaMigrationCompleted); + int failed = getTotal(migrationListener.replicaMigrationFailed); + + assertEquals(partitionCount, completed); + assertEquals(0, failed); + }); + + for (AtomicInteger integer : migrationListener.replicaMigrationCompleted) { + assertThat(integer.get(), Matchers.lessThanOrEqualTo(1)); + } + } + + @Test + public void testMigrationStats_whenMigrationProcessCompletes() { + HazelcastInstance hz1 = hazelcastFactory.newHazelcastInstance(); + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + warmUpPartitions(hz1); + + // Change to NO_MIGRATION to prevent repartitioning + // before 2nd member started and ready. + hz1.getCluster().changeClusterState(ClusterState.NO_MIGRATION); + + PartitionMigrationListenerTest.EventCollectingMigrationListener listener = new PartitionMigrationListenerTest.EventCollectingMigrationListener(); + client.getPartitionService().addMigrationListener(listener); + + HazelcastInstance hz2 = hazelcastFactory.newHazelcastInstance(); + // Back to ACTIVE + changeClusterStateEventually(hz2, ClusterState.ACTIVE); + + PartitionMigrationListenerTest.MigrationEventsPack eventsPack = listener.ensureAndGetSingleEventPack(); + assertMigrationProcessCompleted(eventsPack); + assertMigrationProcessEventsConsistent(eventsPack); + assertMigrationEventsConsistentWithResult(eventsPack); + } + + private void assertRegistrationsSizeEventually(HazelcastInstance instance, int size) { + assertTrueEventually(() -> { + EventService eventService = getNode(instance).getNodeEngine().getEventService(); + Collection registrations = eventService + .getRegistrations(SERVICE_NAME, MIGRATION_EVENT_TOPIC); + assertEquals(size, registrations.size()); + }); + } + + private int getTotal(AtomicInteger[] integers) { + int total = 0; + for (AtomicInteger count : integers) { + total += count.get(); + } + return total; + } +} diff --git a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/PartitionServiceProxyTest.java b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/PartitionServiceProxyTest.java index 9cd836e3d14bb..44de3bd17d564 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/PartitionServiceProxyTest.java +++ b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/PartitionServiceProxyTest.java @@ -18,12 +18,8 @@ import com.hazelcast.client.test.TestHazelcastFactory; import com.hazelcast.core.HazelcastInstance; -import com.hazelcast.internal.util.UuidUtil; -import com.hazelcast.partition.MigrationState; -import com.hazelcast.partition.MigrationListener; import com.hazelcast.partition.Partition; import com.hazelcast.partition.PartitionService; -import com.hazelcast.partition.ReplicaMigrationEvent; import com.hazelcast.test.HazelcastParallelClassRunner; import com.hazelcast.test.annotation.ParallelJVMTest; import com.hazelcast.test.annotation.QuickTest; @@ -57,18 +53,6 @@ public void setup() { client = hazelcastFactory.newHazelcastClient(); } - @Test(expected = UnsupportedOperationException.class) - public void testAddMigrationListener() throws Exception { - PartitionService p = client.getPartitionService(); - p.addMigrationListener(new DumMigrationListener()); - } - - @Test(expected = UnsupportedOperationException.class) - public void testRemoveMigrationListener() throws Exception { - PartitionService p = client.getPartitionService(); - p.removeMigrationListener(UuidUtil.newUnsecureUUID()); - } - @Test public void testGetPartition() { String key = "Key"; @@ -84,8 +68,6 @@ public void testGetPartition() { @Test public void testGetPartitions() { - String key = "Key"; - PartitionService clientPartitionService = client.getPartitionService(); Set clientPartitions = clientPartitionService.getPartitions(); @@ -94,24 +76,4 @@ public void testGetPartitions() { assertEquals(clientPartitions.size(), serverPartitions.size()); } - - class DumMigrationListener implements MigrationListener { - - @Override - public void migrationStarted(MigrationState state) { - } - - @Override - public void migrationFinished(MigrationState state) { - } - - @Override - public void replicaMigrationCompleted(ReplicaMigrationEvent event) { - } - - @Override - public void replicaMigrationFailed(ReplicaMigrationEvent event) { - - } - } } diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java index 37773f4a2f020..d05b0b8b0af80 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java @@ -385,8 +385,72 @@ public void test_ClientTriggerPartitionAssignmentCodec_decodeResponse() { } @Test - public void test_MapPutCodec_encodeRequest() { + 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 partitionId) { + assertTrue(isEqual(aMigrationState, migrationState)); + assertTrue(isEqual(anInt, partitionId)); + } + @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_MapPutCodec_encodeRequest() { + int fileClientMessageIndex = 43; ClientMessage encoded = MapPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -394,14 +458,14 @@ public void test_MapPutCodec_encodeRequest() { @Test public void test_MapPutCodec_decodeResponse() { - int fileClientMessageIndex = 38; + int fileClientMessageIndex = 44; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapPutCodec.decodeResponse(fromFile))); } @Test public void test_MapGetCodec_encodeRequest() { - int fileClientMessageIndex = 39; + int fileClientMessageIndex = 45; ClientMessage encoded = MapGetCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -409,14 +473,14 @@ public void test_MapGetCodec_encodeRequest() { @Test public void test_MapGetCodec_decodeResponse() { - int fileClientMessageIndex = 40; + int fileClientMessageIndex = 46; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapGetCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveCodec_encodeRequest() { - int fileClientMessageIndex = 41; + int fileClientMessageIndex = 47; ClientMessage encoded = MapRemoveCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -424,14 +488,14 @@ public void test_MapRemoveCodec_encodeRequest() { @Test public void test_MapRemoveCodec_decodeResponse() { - int fileClientMessageIndex = 42; + int fileClientMessageIndex = 48; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapRemoveCodec.decodeResponse(fromFile))); } @Test public void test_MapReplaceCodec_encodeRequest() { - int fileClientMessageIndex = 43; + int fileClientMessageIndex = 49; ClientMessage encoded = MapReplaceCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -439,14 +503,14 @@ public void test_MapReplaceCodec_encodeRequest() { @Test public void test_MapReplaceCodec_decodeResponse() { - int fileClientMessageIndex = 44; + int fileClientMessageIndex = 50; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapReplaceCodec.decodeResponse(fromFile))); } @Test public void test_MapReplaceIfSameCodec_encodeRequest() { - int fileClientMessageIndex = 45; + int fileClientMessageIndex = 51; ClientMessage encoded = MapReplaceIfSameCodec.encodeRequest(aString, aData, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -454,14 +518,14 @@ public void test_MapReplaceIfSameCodec_encodeRequest() { @Test public void test_MapReplaceIfSameCodec_decodeResponse() { - int fileClientMessageIndex = 46; + int fileClientMessageIndex = 52; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapReplaceIfSameCodec.decodeResponse(fromFile))); } @Test public void test_MapContainsKeyCodec_encodeRequest() { - int fileClientMessageIndex = 47; + int fileClientMessageIndex = 53; ClientMessage encoded = MapContainsKeyCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -469,14 +533,14 @@ public void test_MapContainsKeyCodec_encodeRequest() { @Test public void test_MapContainsKeyCodec_decodeResponse() { - int fileClientMessageIndex = 48; + int fileClientMessageIndex = 54; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapContainsKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapContainsValueCodec_encodeRequest() { - int fileClientMessageIndex = 49; + int fileClientMessageIndex = 55; ClientMessage encoded = MapContainsValueCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -484,14 +548,14 @@ public void test_MapContainsValueCodec_encodeRequest() { @Test public void test_MapContainsValueCodec_decodeResponse() { - int fileClientMessageIndex = 50; + int fileClientMessageIndex = 56; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapContainsValueCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveIfSameCodec_encodeRequest() { - int fileClientMessageIndex = 51; + int fileClientMessageIndex = 57; ClientMessage encoded = MapRemoveIfSameCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -499,14 +563,14 @@ public void test_MapRemoveIfSameCodec_encodeRequest() { @Test public void test_MapRemoveIfSameCodec_decodeResponse() { - int fileClientMessageIndex = 52; + int fileClientMessageIndex = 58; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveIfSameCodec.decodeResponse(fromFile))); } @Test public void test_MapDeleteCodec_encodeRequest() { - int fileClientMessageIndex = 53; + int fileClientMessageIndex = 59; ClientMessage encoded = MapDeleteCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -514,12 +578,12 @@ public void test_MapDeleteCodec_encodeRequest() { @Test public void test_MapDeleteCodec_decodeResponse() { - int fileClientMessageIndex = 54; + int fileClientMessageIndex = 60; } @Test public void test_MapFlushCodec_encodeRequest() { - int fileClientMessageIndex = 55; + int fileClientMessageIndex = 61; ClientMessage encoded = MapFlushCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -527,12 +591,12 @@ public void test_MapFlushCodec_encodeRequest() { @Test public void test_MapFlushCodec_decodeResponse() { - int fileClientMessageIndex = 56; + int fileClientMessageIndex = 62; } @Test public void test_MapTryRemoveCodec_encodeRequest() { - int fileClientMessageIndex = 57; + int fileClientMessageIndex = 63; ClientMessage encoded = MapTryRemoveCodec.encodeRequest(aString, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -540,14 +604,14 @@ public void test_MapTryRemoveCodec_encodeRequest() { @Test public void test_MapTryRemoveCodec_decodeResponse() { - int fileClientMessageIndex = 58; + int fileClientMessageIndex = 64; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryRemoveCodec.decodeResponse(fromFile))); } @Test public void test_MapTryPutCodec_encodeRequest() { - int fileClientMessageIndex = 59; + int fileClientMessageIndex = 65; ClientMessage encoded = MapTryPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -555,14 +619,14 @@ public void test_MapTryPutCodec_encodeRequest() { @Test public void test_MapTryPutCodec_decodeResponse() { - int fileClientMessageIndex = 60; + int fileClientMessageIndex = 66; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryPutCodec.decodeResponse(fromFile))); } @Test public void test_MapPutTransientCodec_encodeRequest() { - int fileClientMessageIndex = 61; + int fileClientMessageIndex = 67; ClientMessage encoded = MapPutTransientCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -570,12 +634,12 @@ public void test_MapPutTransientCodec_encodeRequest() { @Test public void test_MapPutTransientCodec_decodeResponse() { - int fileClientMessageIndex = 62; + int fileClientMessageIndex = 68; } @Test public void test_MapPutIfAbsentCodec_encodeRequest() { - int fileClientMessageIndex = 63; + int fileClientMessageIndex = 69; ClientMessage encoded = MapPutIfAbsentCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -583,14 +647,14 @@ public void test_MapPutIfAbsentCodec_encodeRequest() { @Test public void test_MapPutIfAbsentCodec_decodeResponse() { - int fileClientMessageIndex = 64; + int fileClientMessageIndex = 70; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapPutIfAbsentCodec.decodeResponse(fromFile))); } @Test public void test_MapSetCodec_encodeRequest() { - int fileClientMessageIndex = 65; + int fileClientMessageIndex = 71; ClientMessage encoded = MapSetCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -598,12 +662,12 @@ public void test_MapSetCodec_encodeRequest() { @Test public void test_MapSetCodec_decodeResponse() { - int fileClientMessageIndex = 66; + int fileClientMessageIndex = 72; } @Test public void test_MapLockCodec_encodeRequest() { - int fileClientMessageIndex = 67; + int fileClientMessageIndex = 73; ClientMessage encoded = MapLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -611,12 +675,12 @@ public void test_MapLockCodec_encodeRequest() { @Test public void test_MapLockCodec_decodeResponse() { - int fileClientMessageIndex = 68; + int fileClientMessageIndex = 74; } @Test public void test_MapTryLockCodec_encodeRequest() { - int fileClientMessageIndex = 69; + int fileClientMessageIndex = 75; ClientMessage encoded = MapTryLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -624,14 +688,14 @@ public void test_MapTryLockCodec_encodeRequest() { @Test public void test_MapTryLockCodec_decodeResponse() { - int fileClientMessageIndex = 70; + int fileClientMessageIndex = 76; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryLockCodec.decodeResponse(fromFile))); } @Test public void test_MapIsLockedCodec_encodeRequest() { - int fileClientMessageIndex = 71; + int fileClientMessageIndex = 77; ClientMessage encoded = MapIsLockedCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -639,14 +703,14 @@ public void test_MapIsLockedCodec_encodeRequest() { @Test public void test_MapIsLockedCodec_decodeResponse() { - int fileClientMessageIndex = 72; + int fileClientMessageIndex = 78; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapIsLockedCodec.decodeResponse(fromFile))); } @Test public void test_MapUnlockCodec_encodeRequest() { - int fileClientMessageIndex = 73; + int fileClientMessageIndex = 79; ClientMessage encoded = MapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -654,12 +718,12 @@ public void test_MapUnlockCodec_encodeRequest() { @Test public void test_MapUnlockCodec_decodeResponse() { - int fileClientMessageIndex = 74; + int fileClientMessageIndex = 80; } @Test public void test_MapAddInterceptorCodec_encodeRequest() { - int fileClientMessageIndex = 75; + int fileClientMessageIndex = 81; ClientMessage encoded = MapAddInterceptorCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -667,14 +731,14 @@ public void test_MapAddInterceptorCodec_encodeRequest() { @Test public void test_MapAddInterceptorCodec_decodeResponse() { - int fileClientMessageIndex = 76; + int fileClientMessageIndex = 82; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapAddInterceptorCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveInterceptorCodec_encodeRequest() { - int fileClientMessageIndex = 77; + int fileClientMessageIndex = 83; ClientMessage encoded = MapRemoveInterceptorCodec.encodeRequest(aString, aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -682,14 +746,14 @@ public void test_MapRemoveInterceptorCodec_encodeRequest() { @Test public void test_MapRemoveInterceptorCodec_decodeResponse() { - int fileClientMessageIndex = 78; + int fileClientMessageIndex = 84; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveInterceptorCodec.decodeResponse(fromFile))); } @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 79; + int fileClientMessageIndex = 85; ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -697,7 +761,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 80; + int fileClientMessageIndex = 86; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(fromFile))); } @@ -717,7 +781,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { - int fileClientMessageIndex = 81; + int fileClientMessageIndex = 87; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyWithPredicateCodecHandler handler = new MapAddEntryListenerToKeyWithPredicateCodecHandler(); handler.handle(fromFile); @@ -725,7 +789,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 82; + int fileClientMessageIndex = 88; ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -733,7 +797,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { @Test public void test_MapAddEntryListenerWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 83; + int fileClientMessageIndex = 89; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerWithPredicateCodec.decodeResponse(fromFile))); } @@ -753,7 +817,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { - int fileClientMessageIndex = 84; + int fileClientMessageIndex = 90; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerWithPredicateCodecHandler handler = new MapAddEntryListenerWithPredicateCodecHandler(); handler.handle(fromFile); @@ -761,7 +825,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { - int fileClientMessageIndex = 85; + int fileClientMessageIndex = 91; ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -769,7 +833,7 @@ public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { @Test public void test_MapAddEntryListenerToKeyCodec_decodeResponse() { - int fileClientMessageIndex = 86; + int fileClientMessageIndex = 92; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); } @@ -789,7 +853,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { - int fileClientMessageIndex = 87; + int fileClientMessageIndex = 93; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyCodecHandler handler = new MapAddEntryListenerToKeyCodecHandler(); handler.handle(fromFile); @@ -797,7 +861,7 @@ public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerCodec_encodeRequest() { - int fileClientMessageIndex = 88; + int fileClientMessageIndex = 94; ClientMessage encoded = MapAddEntryListenerCodec.encodeRequest(aString, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -805,7 +869,7 @@ public void test_MapAddEntryListenerCodec_encodeRequest() { @Test public void test_MapAddEntryListenerCodec_decodeResponse() { - int fileClientMessageIndex = 89; + int fileClientMessageIndex = 95; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerCodec.decodeResponse(fromFile))); } @@ -825,7 +889,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerCodec_handleEntryEvent() { - int fileClientMessageIndex = 90; + int fileClientMessageIndex = 96; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerCodecHandler handler = new MapAddEntryListenerCodecHandler(); handler.handle(fromFile); @@ -833,7 +897,7 @@ public void test_MapAddEntryListenerCodec_handleEntryEvent() { @Test public void test_MapRemoveEntryListenerCodec_encodeRequest() { - int fileClientMessageIndex = 91; + int fileClientMessageIndex = 97; ClientMessage encoded = MapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -841,14 +905,14 @@ public void test_MapRemoveEntryListenerCodec_encodeRequest() { @Test public void test_MapRemoveEntryListenerCodec_decodeResponse() { - int fileClientMessageIndex = 92; + int fileClientMessageIndex = 98; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveEntryListenerCodec.decodeResponse(fromFile))); } @Test public void test_MapAddPartitionLostListenerCodec_encodeRequest() { - int fileClientMessageIndex = 93; + int fileClientMessageIndex = 99; ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -856,7 +920,7 @@ public void test_MapAddPartitionLostListenerCodec_encodeRequest() { @Test public void test_MapAddPartitionLostListenerCodec_decodeResponse() { - int fileClientMessageIndex = 94; + int fileClientMessageIndex = 100; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddPartitionLostListenerCodec.decodeResponse(fromFile))); } @@ -871,7 +935,7 @@ public void handleMapPartitionLostEvent(int partitionId, java.util.UUID uuid) { @Test public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() { - int fileClientMessageIndex = 95; + int fileClientMessageIndex = 101; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddPartitionLostListenerCodecHandler handler = new MapAddPartitionLostListenerCodecHandler(); handler.handle(fromFile); @@ -879,7 +943,7 @@ public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() @Test public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { - int fileClientMessageIndex = 96; + int fileClientMessageIndex = 102; ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -887,14 +951,14 @@ public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { @Test public void test_MapRemovePartitionLostListenerCodec_decodeResponse() { - int fileClientMessageIndex = 97; + int fileClientMessageIndex = 103; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemovePartitionLostListenerCodec.decodeResponse(fromFile))); } @Test public void test_MapGetEntryViewCodec_encodeRequest() { - int fileClientMessageIndex = 98; + int fileClientMessageIndex = 104; ClientMessage encoded = MapGetEntryViewCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -902,7 +966,7 @@ public void test_MapGetEntryViewCodec_encodeRequest() { @Test public void test_MapGetEntryViewCodec_decodeResponse() { - int fileClientMessageIndex = 99; + int fileClientMessageIndex = 105; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetEntryViewCodec.ResponseParameters parameters = MapGetEntryViewCodec.decodeResponse(fromFile); assertTrue(isEqual(null, parameters.response)); @@ -911,7 +975,7 @@ public void test_MapGetEntryViewCodec_decodeResponse() { @Test public void test_MapEvictCodec_encodeRequest() { - int fileClientMessageIndex = 100; + int fileClientMessageIndex = 106; ClientMessage encoded = MapEvictCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -919,14 +983,14 @@ public void test_MapEvictCodec_encodeRequest() { @Test public void test_MapEvictCodec_decodeResponse() { - int fileClientMessageIndex = 101; + int fileClientMessageIndex = 107; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapEvictCodec.decodeResponse(fromFile))); } @Test public void test_MapEvictAllCodec_encodeRequest() { - int fileClientMessageIndex = 102; + int fileClientMessageIndex = 108; ClientMessage encoded = MapEvictAllCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -934,12 +998,12 @@ public void test_MapEvictAllCodec_encodeRequest() { @Test public void test_MapEvictAllCodec_decodeResponse() { - int fileClientMessageIndex = 103; + int fileClientMessageIndex = 109; } @Test public void test_MapLoadAllCodec_encodeRequest() { - int fileClientMessageIndex = 104; + int fileClientMessageIndex = 110; ClientMessage encoded = MapLoadAllCodec.encodeRequest(aString, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -947,12 +1011,12 @@ public void test_MapLoadAllCodec_encodeRequest() { @Test public void test_MapLoadAllCodec_decodeResponse() { - int fileClientMessageIndex = 105; + int fileClientMessageIndex = 111; } @Test public void test_MapLoadGivenKeysCodec_encodeRequest() { - int fileClientMessageIndex = 106; + int fileClientMessageIndex = 112; ClientMessage encoded = MapLoadGivenKeysCodec.encodeRequest(aString, aListOfData, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -960,12 +1024,12 @@ public void test_MapLoadGivenKeysCodec_encodeRequest() { @Test public void test_MapLoadGivenKeysCodec_decodeResponse() { - int fileClientMessageIndex = 107; + int fileClientMessageIndex = 113; } @Test public void test_MapKeySetCodec_encodeRequest() { - int fileClientMessageIndex = 108; + int fileClientMessageIndex = 114; ClientMessage encoded = MapKeySetCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -973,14 +1037,14 @@ public void test_MapKeySetCodec_encodeRequest() { @Test public void test_MapKeySetCodec_decodeResponse() { - int fileClientMessageIndex = 109; + int fileClientMessageIndex = 115; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapKeySetCodec.decodeResponse(fromFile))); } @Test public void test_MapGetAllCodec_encodeRequest() { - int fileClientMessageIndex = 110; + int fileClientMessageIndex = 116; ClientMessage encoded = MapGetAllCodec.encodeRequest(aString, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -988,14 +1052,14 @@ public void test_MapGetAllCodec_encodeRequest() { @Test public void test_MapGetAllCodec_decodeResponse() { - int fileClientMessageIndex = 111; + int fileClientMessageIndex = 117; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapGetAllCodec.decodeResponse(fromFile))); } @Test public void test_MapValuesCodec_encodeRequest() { - int fileClientMessageIndex = 112; + int fileClientMessageIndex = 118; ClientMessage encoded = MapValuesCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1003,14 +1067,14 @@ public void test_MapValuesCodec_encodeRequest() { @Test public void test_MapValuesCodec_decodeResponse() { - int fileClientMessageIndex = 113; + int fileClientMessageIndex = 119; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapValuesCodec.decodeResponse(fromFile))); } @Test public void test_MapEntrySetCodec_encodeRequest() { - int fileClientMessageIndex = 114; + int fileClientMessageIndex = 120; ClientMessage encoded = MapEntrySetCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1018,14 +1082,14 @@ public void test_MapEntrySetCodec_encodeRequest() { @Test public void test_MapEntrySetCodec_decodeResponse() { - int fileClientMessageIndex = 115; + int fileClientMessageIndex = 121; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapEntrySetCodec.decodeResponse(fromFile))); } @Test public void test_MapKeySetWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 116; + int fileClientMessageIndex = 122; ClientMessage encoded = MapKeySetWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1033,14 +1097,14 @@ public void test_MapKeySetWithPredicateCodec_encodeRequest() { @Test public void test_MapKeySetWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 117; + int fileClientMessageIndex = 123; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapKeySetWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapValuesWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 118; + int fileClientMessageIndex = 124; ClientMessage encoded = MapValuesWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1048,14 +1112,14 @@ public void test_MapValuesWithPredicateCodec_encodeRequest() { @Test public void test_MapValuesWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 119; + int fileClientMessageIndex = 125; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapValuesWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapEntriesWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 120; + int fileClientMessageIndex = 126; ClientMessage encoded = MapEntriesWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1063,14 +1127,14 @@ public void test_MapEntriesWithPredicateCodec_encodeRequest() { @Test public void test_MapEntriesWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 121; + int fileClientMessageIndex = 127; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapEntriesWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapAddIndexCodec_encodeRequest() { - int fileClientMessageIndex = 122; + int fileClientMessageIndex = 128; ClientMessage encoded = MapAddIndexCodec.encodeRequest(aString, anIndexConfig); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1078,12 +1142,12 @@ public void test_MapAddIndexCodec_encodeRequest() { @Test public void test_MapAddIndexCodec_decodeResponse() { - int fileClientMessageIndex = 123; + int fileClientMessageIndex = 129; } @Test public void test_MapSizeCodec_encodeRequest() { - int fileClientMessageIndex = 124; + int fileClientMessageIndex = 130; ClientMessage encoded = MapSizeCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1091,14 +1155,14 @@ public void test_MapSizeCodec_encodeRequest() { @Test public void test_MapSizeCodec_decodeResponse() { - int fileClientMessageIndex = 125; + int fileClientMessageIndex = 131; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anInt, MapSizeCodec.decodeResponse(fromFile))); } @Test public void test_MapIsEmptyCodec_encodeRequest() { - int fileClientMessageIndex = 126; + int fileClientMessageIndex = 132; ClientMessage encoded = MapIsEmptyCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1106,14 +1170,14 @@ public void test_MapIsEmptyCodec_encodeRequest() { @Test public void test_MapIsEmptyCodec_decodeResponse() { - int fileClientMessageIndex = 127; + int fileClientMessageIndex = 133; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapIsEmptyCodec.decodeResponse(fromFile))); } @Test public void test_MapPutAllCodec_encodeRequest() { - int fileClientMessageIndex = 128; + int fileClientMessageIndex = 134; ClientMessage encoded = MapPutAllCodec.encodeRequest(aString, aListOfDataToData, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1121,12 +1185,12 @@ public void test_MapPutAllCodec_encodeRequest() { @Test public void test_MapPutAllCodec_decodeResponse() { - int fileClientMessageIndex = 129; + int fileClientMessageIndex = 135; } @Test public void test_MapClearCodec_encodeRequest() { - int fileClientMessageIndex = 130; + int fileClientMessageIndex = 136; ClientMessage encoded = MapClearCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1134,12 +1198,12 @@ public void test_MapClearCodec_encodeRequest() { @Test public void test_MapClearCodec_decodeResponse() { - int fileClientMessageIndex = 131; + int fileClientMessageIndex = 137; } @Test public void test_MapExecuteOnKeyCodec_encodeRequest() { - int fileClientMessageIndex = 132; + int fileClientMessageIndex = 138; ClientMessage encoded = MapExecuteOnKeyCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1147,14 +1211,14 @@ public void test_MapExecuteOnKeyCodec_encodeRequest() { @Test public void test_MapExecuteOnKeyCodec_decodeResponse() { - int fileClientMessageIndex = 133; + int fileClientMessageIndex = 139; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapExecuteOnKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapSubmitToKeyCodec_encodeRequest() { - int fileClientMessageIndex = 134; + int fileClientMessageIndex = 140; ClientMessage encoded = MapSubmitToKeyCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1162,14 +1226,14 @@ public void test_MapSubmitToKeyCodec_encodeRequest() { @Test public void test_MapSubmitToKeyCodec_decodeResponse() { - int fileClientMessageIndex = 135; + int fileClientMessageIndex = 141; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapSubmitToKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteOnAllKeysCodec_encodeRequest() { - int fileClientMessageIndex = 136; + int fileClientMessageIndex = 142; ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1177,14 +1241,14 @@ public void test_MapExecuteOnAllKeysCodec_encodeRequest() { @Test public void test_MapExecuteOnAllKeysCodec_decodeResponse() { - int fileClientMessageIndex = 137; + int fileClientMessageIndex = 143; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteOnAllKeysCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 138; + int fileClientMessageIndex = 144; ClientMessage encoded = MapExecuteWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1192,14 +1256,14 @@ public void test_MapExecuteWithPredicateCodec_encodeRequest() { @Test public void test_MapExecuteWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 139; + int fileClientMessageIndex = 145; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteOnKeysCodec_encodeRequest() { - int fileClientMessageIndex = 140; + int fileClientMessageIndex = 146; ClientMessage encoded = MapExecuteOnKeysCodec.encodeRequest(aString, aData, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1207,14 +1271,14 @@ public void test_MapExecuteOnKeysCodec_encodeRequest() { @Test public void test_MapExecuteOnKeysCodec_decodeResponse() { - int fileClientMessageIndex = 141; + int fileClientMessageIndex = 147; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteOnKeysCodec.decodeResponse(fromFile))); } @Test public void test_MapForceUnlockCodec_encodeRequest() { - int fileClientMessageIndex = 142; + int fileClientMessageIndex = 148; ClientMessage encoded = MapForceUnlockCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1222,12 +1286,12 @@ public void test_MapForceUnlockCodec_encodeRequest() { @Test public void test_MapForceUnlockCodec_decodeResponse() { - int fileClientMessageIndex = 143; + int fileClientMessageIndex = 149; } @Test public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 144; + int fileClientMessageIndex = 150; ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1235,7 +1299,7 @@ public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 145; + int fileClientMessageIndex = 151; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapKeySetWithPagingPredicateCodec.ResponseParameters parameters = MapKeySetWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfData, parameters.response)); @@ -1244,7 +1308,7 @@ public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 146; + int fileClientMessageIndex = 152; ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1252,7 +1316,7 @@ public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 147; + int fileClientMessageIndex = 153; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapValuesWithPagingPredicateCodec.ResponseParameters parameters = MapValuesWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfData, parameters.response)); @@ -1261,7 +1325,7 @@ public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 148; + int fileClientMessageIndex = 154; ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1269,7 +1333,7 @@ public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 149; + int fileClientMessageIndex = 155; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEntriesWithPagingPredicateCodec.ResponseParameters parameters = MapEntriesWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfDataToData, parameters.response)); @@ -1278,7 +1342,7 @@ public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapFetchKeysCodec_encodeRequest() { - int fileClientMessageIndex = 150; + int fileClientMessageIndex = 156; ClientMessage encoded = MapFetchKeysCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1286,7 +1350,7 @@ public void test_MapFetchKeysCodec_encodeRequest() { @Test public void test_MapFetchKeysCodec_decodeResponse() { - int fileClientMessageIndex = 151; + int fileClientMessageIndex = 157; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchKeysCodec.ResponseParameters parameters = MapFetchKeysCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); @@ -1295,7 +1359,7 @@ public void test_MapFetchKeysCodec_decodeResponse() { @Test public void test_MapFetchEntriesCodec_encodeRequest() { - int fileClientMessageIndex = 152; + int fileClientMessageIndex = 158; ClientMessage encoded = MapFetchEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1303,7 +1367,7 @@ public void test_MapFetchEntriesCodec_encodeRequest() { @Test public void test_MapFetchEntriesCodec_decodeResponse() { - int fileClientMessageIndex = 153; + int fileClientMessageIndex = 159; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchEntriesCodec.ResponseParameters parameters = MapFetchEntriesCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); @@ -1312,7 +1376,7 @@ public void test_MapFetchEntriesCodec_decodeResponse() { @Test public void test_MapAggregateCodec_encodeRequest() { - int fileClientMessageIndex = 154; + int fileClientMessageIndex = 160; ClientMessage encoded = MapAggregateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1320,14 +1384,14 @@ public void test_MapAggregateCodec_encodeRequest() { @Test public void test_MapAggregateCodec_decodeResponse() { - int fileClientMessageIndex = 155; + int fileClientMessageIndex = 161; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapAggregateCodec.decodeResponse(fromFile))); } @Test public void test_MapAggregateWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 156; + int fileClientMessageIndex = 162; ClientMessage encoded = MapAggregateWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1335,14 +1399,14 @@ public void test_MapAggregateWithPredicateCodec_encodeRequest() { @Test public void test_MapAggregateWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 157; + int fileClientMessageIndex = 163; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapAggregateWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapProjectCodec_encodeRequest() { - int fileClientMessageIndex = 158; + int fileClientMessageIndex = 164; ClientMessage encoded = MapProjectCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1350,14 +1414,14 @@ public void test_MapProjectCodec_encodeRequest() { @Test public void test_MapProjectCodec_decodeResponse() { - int fileClientMessageIndex = 159; + int fileClientMessageIndex = 165; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapProjectCodec.decodeResponse(fromFile))); } @Test public void test_MapProjectWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 160; + int fileClientMessageIndex = 166; ClientMessage encoded = MapProjectWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1365,14 +1429,14 @@ public void test_MapProjectWithPredicateCodec_encodeRequest() { @Test public void test_MapProjectWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 161; + int fileClientMessageIndex = 167; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapProjectWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { - int fileClientMessageIndex = 162; + int fileClientMessageIndex = 168; ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1380,7 +1444,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { - int fileClientMessageIndex = 163; + int fileClientMessageIndex = 169; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchNearCacheInvalidationMetadataCodec.ResponseParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfStringToListOfIntegerToLong, parameters.namePartitionSequenceList)); @@ -1389,7 +1453,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { @Test public void test_MapRemoveAllCodec_encodeRequest() { - int fileClientMessageIndex = 164; + int fileClientMessageIndex = 170; ClientMessage encoded = MapRemoveAllCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1397,12 +1461,12 @@ public void test_MapRemoveAllCodec_encodeRequest() { @Test public void test_MapRemoveAllCodec_decodeResponse() { - int fileClientMessageIndex = 165; + int fileClientMessageIndex = 171; } @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { - int fileClientMessageIndex = 166; + int fileClientMessageIndex = 172; ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeRequest(aString, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1410,7 +1474,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_decodeResponse() { - int fileClientMessageIndex = 167; + int fileClientMessageIndex = 173; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddNearCacheInvalidationListenerCodec.decodeResponse(fromFile))); } @@ -1434,7 +1498,7 @@ public void handleIMapBatchInvalidationEvent(java.util.Collection aListOfCpMembers; + public static MigrationState aMigrationState = new MigrationStateImpl(aLong, anInt, anInt, aLong); static { try { diff --git a/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java b/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java index b637b38a3f6ff..591f3b2be8444 100644 --- a/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java +++ b/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java @@ -30,8 +30,8 @@ import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; -import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_FINISHED; -import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_STARTED; +import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED; +import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; diff --git a/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java b/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java index f4377cc8d69cc..b1e57586067f7 100644 --- a/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java +++ b/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java @@ -209,11 +209,11 @@ public void testMigrationStats_afterPartitionsLost_when_NO_MIGRATION() { } } - private void assertMigrationProcessCompleted(MigrationEventsPack eventsPack) { + public static void assertMigrationProcessCompleted(MigrationEventsPack eventsPack) { assertTrueEventually(() -> assertNotNull(eventsPack.migrationProcessCompleted)); } - private void assertMigrationProcessEventsConsistent(MigrationEventsPack eventsPack) { + public static void assertMigrationProcessEventsConsistent(MigrationEventsPack eventsPack) { MigrationState migrationPlan = eventsPack.migrationProcessStarted; assertThat(migrationPlan.getStartTime(), greaterThan(0L)); assertThat(migrationPlan.getPlannedMigrations(), greaterThan(0)); @@ -225,7 +225,7 @@ private void assertMigrationProcessEventsConsistent(MigrationEventsPack eventsPa assertEquals(0, migrationResult.getRemainingMigrations()); } - private void assertMigrationEventsConsistentWithResult(MigrationEventsPack eventsPack) { + public static void assertMigrationEventsConsistentWithResult(MigrationEventsPack eventsPack) { MigrationState migrationResult = eventsPack.migrationProcessCompleted; List migrationsCompleted = eventsPack.migrationsCompleted; @@ -362,22 +362,20 @@ public void testRemoveMigrationListener() { verify(listener, never()).replicaMigrationCompleted(any(ReplicaMigrationEvent.class)); } - - @SuppressWarnings("SameParameterValue") private void assertAllLessThanOrEqual(AtomicInteger[] integers, int expected) { for (AtomicInteger integer : integers) { assertThat(integer.get(), Matchers.lessThanOrEqualTo(expected)); } } - private static class CountingMigrationListener implements MigrationListener { + public static final class CountingMigrationListener implements MigrationListener { - final AtomicInteger migrationStarted; - final AtomicInteger migrationCompleted; - final AtomicInteger[] replicaMigrationCompleted; - final AtomicInteger[] replicaMigrationFailed; + public final AtomicInteger migrationStarted; + public final AtomicInteger migrationCompleted; + public final AtomicInteger[] replicaMigrationCompleted; + public final AtomicInteger[] replicaMigrationFailed; - CountingMigrationListener(int partitionCount) { + public CountingMigrationListener(int partitionCount) { migrationStarted = new AtomicInteger(); migrationCompleted = new AtomicInteger(); replicaMigrationCompleted = new AtomicInteger[partitionCount]; @@ -413,7 +411,7 @@ public void replicaMigrationFailed(ReplicaMigrationEvent event) { // Migration events are published and processed in order in a single event thread. // So we can rely on that here... - private static class EventCollectingMigrationListener implements MigrationListener { + public static final class EventCollectingMigrationListener implements MigrationListener { final List allEventPacks = Collections.synchronizedList(new ArrayList<>()); volatile MigrationEventsPack currentEvents; @@ -449,7 +447,7 @@ List ensureAndGetEventPacks(int count) { return allEventPacks.subList(0, count); } - MigrationEventsPack ensureAndGetSingleEventPack() { + public MigrationEventsPack ensureAndGetSingleEventPack() { return ensureAndGetEventPacks(1).get(0); } @@ -459,16 +457,11 @@ void awaitEventPacksComplete(int count) { assertNull(currentEvents); }); } - - void reset() { - allEventPacks.clear(); - currentEvents = null; - } } - private static class MigrationEventsPack { - volatile MigrationState migrationProcessStarted; - volatile MigrationState migrationProcessCompleted; - final List migrationsCompleted = Collections.synchronizedList(new ArrayList<>()); + public static final class MigrationEventsPack { + public volatile MigrationState migrationProcessStarted; + public volatile MigrationState migrationProcessCompleted; + public final List migrationsCompleted = Collections.synchronizedList(new ArrayList<>()); } } diff --git a/hazelcast/src/test/resources/2.1.protocol.compatibility.binary b/hazelcast/src/test/resources/2.1.protocol.compatibility.binary index 30b2784b04762973cf38458d1491c21cfdda376b..018bfd7c0c8b33779cbace2b7e4b64c7f418e69c 100644 GIT binary patch delta 156 zcmezHmuYST^M)jL4siw`c)%byS&&tXNswW3VXHK!6iDn4h}YjQ&L#)qF-*R07(ZUA^-pY delta 14 VcmbQ+!2IDa(}pDW&HWsG+W|9*2DktK diff --git a/hazelcast/src/test/resources/2.1.protocol.compatibility.null.binary b/hazelcast/src/test/resources/2.1.protocol.compatibility.null.binary index e671ea69e00ee59ae918dc6e459e3c64a04c2c1c..6a14a5b7ff944109282bb66a0634006343f6fce4 100644 GIT binary patch delta 171 zcmex(nrYrSrVT>u9O4W>@PI*Z@uo9#L7&jSE5vIcDc From bdfec61bc81d797d53e7ab2b322e19577e13474a Mon Sep 17 00:00:00 2001 From: petjot Date: Thu, 29 Oct 2020 20:58:58 +0100 Subject: [PATCH 02/12] Fix sending migration event order to the client --- .../task/AddMigrationListenerMessageTask.java | 54 +++++---- .../RemoveMigrationListenerMessageTask.java | 2 +- .../impl/proxy/PartitionServiceProxy.java | 70 +++++++----- .../impl/spi/ClientPartitionService.java | 1 + .../internal/partition/IPartitionService.java | 4 +- .../partition/InternalPartitionService.java | 1 + .../impl/InternalPartitionServiceImpl.java | 10 +- .../partition/impl/PartitionEventManager.java | 3 +- .../ClientMigrationListenerTest.java | 108 ++++++++---------- .../PartitionMigrationListenerTest.java | 17 +-- 10 files changed, 136 insertions(+), 134 deletions(-) diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java index a555a4f7eda69..175b0dd13d573 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -31,6 +31,7 @@ import java.util.concurrent.CompletableFuture; import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; +import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC_ORDER_KEY; import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED; import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED; import static com.hazelcast.spi.impl.InternalCompletableFuture.newCompletedFuture; @@ -44,31 +45,9 @@ public AddMigrationListenerMessageTask(ClientMessage clientMessage, Node node, C @Override protected CompletableFuture processInternal() { - final IPartitionService partitionService = getService(getServiceName()); + IPartitionService partitionService = getService(getServiceName()); - - final MigrationListener listener = new MigrationListener() { - - @Override - public void migrationStarted(MigrationState state) { - sendIfAlive(encodeMigrationEvent(state, MIGRATION_STARTED)); - } - - @Override - public void migrationFinished(MigrationState state) { - sendIfAlive(encodeMigrationEvent(state, MIGRATION_FINISHED)); - } - - @Override - public void replicaMigrationCompleted(ReplicaMigrationEvent event) { - sendIfAlive(encodeReplicaMigrationEvent(event)); - } - - @Override - public void replicaMigrationFailed(ReplicaMigrationEvent event) { - sendIfAlive(encodeReplicaMigrationEvent(event)); - } - }; + MigrationListener listener = createMigrationListener(); if (parameters) { return newCompletedFuture(partitionService.addLocalMigrationListener(listener)); @@ -77,9 +56,34 @@ public void replicaMigrationFailed(ReplicaMigrationEvent event) { return partitionService.addMigrationListenerAsync(listener); } + private MigrationListener createMigrationListener() { + return new MigrationListener() { + + @Override + public void migrationStarted(MigrationState state) { + sendIfAlive(encodeMigrationEvent(state, MIGRATION_STARTED)); + } + + @Override + public void migrationFinished(MigrationState state) { + sendIfAlive(encodeMigrationEvent(state, MIGRATION_FINISHED)); + } + + @Override + public void replicaMigrationCompleted(ReplicaMigrationEvent event) { + sendIfAlive(encodeReplicaMigrationEvent(event)); + } + + @Override + public void replicaMigrationFailed(ReplicaMigrationEvent event) { + sendIfAlive(encodeReplicaMigrationEvent(event)); + } + }; + } + private void sendIfAlive(ClientMessage eventMessage) { if (endpoint.isAlive()) { - sendClientMessage(null, eventMessage); + sendClientMessage(MIGRATION_EVENT_TOPIC_ORDER_KEY, eventMessage); } } diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java index ec05dea715957..c9ac491a2ce79 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java @@ -35,7 +35,7 @@ public RemoveMigrationListenerMessageTask(ClientMessage clientMessage, Node node @Override protected Future deRegisterListener() { - final InternalPartitionService service = getService(InternalPartitionService.SERVICE_NAME); + InternalPartitionService service = getService(InternalPartitionService.SERVICE_NAME); return service.removeMigrationListenerAsync(parameters); } diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java index 125142704d7e1..fad5551fe0e5d 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java @@ -56,7 +56,8 @@ public final class PartitionServiceProxy implements PartitionService { private final ClientClusterService clusterService; public PartitionServiceProxy(ClientPartitionService partitionService, - ClientListenerService listenerService, ClientClusterService clusterService) { + ClientListenerService listenerService, + ClientClusterService clusterService) { this.partitionService = partitionService; this.listenerService = listenerService; this.clusterService = clusterService; @@ -81,22 +82,51 @@ public Partition getPartition(@Nonnull Object key) { } @Override - public UUID addMigrationListener(MigrationListener migrationListener) { + public UUID addMigrationListener(@Nonnull MigrationListener migrationListener) { + checkNotNull(migrationListener, "migrationListener can't be null"); EventHandler handler = new ClientMigrationEventHandler(migrationListener); return listenerService.registerListener(createMigrationListenerCodec(), handler); } @Override public boolean removeMigrationListener(UUID registrationId) { + checkNotNull(registrationId, "registrationId can't be null"); return listenerService.deregisterListener(registrationId); } @Override - public UUID addPartitionLostListener(PartitionLostListener partitionLostListener) { + public UUID addPartitionLostListener(@Nonnull PartitionLostListener partitionLostListener) { + checkNotNull(partitionLostListener, "migrationListener can't be null"); EventHandler handler = new ClientPartitionLostEventHandler(partitionLostListener); return listenerService.registerListener(createPartitionLostListenerCodec(), handler); } + @Override + public boolean removePartitionLostListener(UUID registrationId) { + checkNotNull(registrationId, "registrationId can't be null"); + return listenerService.deregisterListener(registrationId); + } + + @Override + public boolean isClusterSafe() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isMemberSafe(Member member) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean isLocalMemberSafe() { + throw new UnsupportedOperationException(); + } + + @Override + public boolean forceLocalMemberToBeSafe(long timeout, TimeUnit unit) { + throw new UnsupportedOperationException(); + } + private ListenerMessageCodec createPartitionLostListenerCodec() { return new ListenerMessageCodec() { @Override @@ -145,31 +175,6 @@ public boolean decodeRemoveResponse(ClientMessage clientMessage) { }; } - @Override - public boolean removePartitionLostListener(UUID registrationId) { - return listenerService.deregisterListener(registrationId); - } - - @Override - public boolean isClusterSafe() { - throw new UnsupportedOperationException(); - } - - @Override - public boolean isMemberSafe(Member member) { - throw new UnsupportedOperationException(); - } - - @Override - public boolean isLocalMemberSafe() { - throw new UnsupportedOperationException(); - } - - @Override - public boolean forceLocalMemberToBeSafe(long timeout, TimeUnit unit) { - throw new UnsupportedOperationException(); - } - private class ClientPartitionLostEventHandler extends ClientAddPartitionLostListenerCodec.AbstractEventHandler implements EventHandler { @@ -195,7 +200,6 @@ private class ClientMigrationEventHandler extends ClientAddMigrationListenerCode this.migrationEventHandler = new MigrationEventHandler(listener); } - @Override public void handleMigrationEvent(MigrationState migrationState, int partitionId) { migrationEventHandler.handleMigrationState(migrationState, partitionId); @@ -210,13 +214,17 @@ public void handleReplicaMigrationEvent(MigrationState migrationState, boolean success, long elapsedTime) { - Member source = sourceUuid != null ? clusterService.getMember(sourceUuid) : null; - Member destination = destUuid != null ? clusterService.getMember(destUuid) : null; + @Nullable Member source = findMember(sourceUuid); + @Nullable Member destination = findMember(destUuid); ReplicaMigrationEvent event = new ReplicaMigrationEventImpl(migrationState, partitionId, replicaIndex, source, destination, success, elapsedTime); migrationEventHandler.handleReplicaMigration(event); } + + private Member findMember(@Nullable UUID memberUuid) { + return memberUuid != null ? clusterService.getMember(memberUuid) : null; + } } } diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java b/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java index 6c2d098aff432..9016bc6b85428 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/spi/ClientPartitionService.java @@ -55,4 +55,5 @@ public interface ClientPartitionService { int getPartitionCount(); Partition getPartition(int partitionId); + } diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java index 6d40cff07f36e..14c54733089df 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/IPartitionService.java @@ -133,6 +133,8 @@ public interface IPartitionService extends CoreService { CompletableFuture addMigrationListenerAsync(MigrationListener migrationListener); + UUID addLocalMigrationListener(MigrationListener migrationListener); + boolean removeMigrationListener(UUID registrationId); CompletableFuture removeMigrationListenerAsync(UUID registrationId); @@ -143,8 +145,6 @@ public interface IPartitionService extends CoreService { UUID addLocalPartitionLostListener(PartitionLostListener partitionLostListener); - UUID addLocalMigrationListener(MigrationListener migrationListener); - boolean removePartitionLostListener(UUID registrationId); CompletableFuture removePartitionLostListenerAsync(UUID registrationId); diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java index b72f1a58c22bc..a7adc0932c89a 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java @@ -35,6 +35,7 @@ public interface InternalPartitionService extends IPartitionService, ManagedServ * Static constant for dispatching and listening migration events */ String MIGRATION_EVENT_TOPIC = ".migration"; + int MIGRATION_EVENT_TOPIC_ORDER_KEY = MIGRATION_EVENT_TOPIC.hashCode(); /** * Static constant for dispatching and listening internal partition lost events diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java index e770c522f1c76..53148f95a59d0 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/InternalPartitionServiceImpl.java @@ -1228,6 +1228,11 @@ public UUID addMigrationListener(MigrationListener listener) { return partitionEventManager.addMigrationListener(listener); } + @Override + public CompletableFuture addMigrationListenerAsync(MigrationListener migrationListener) { + return partitionEventManager.addMigrationListenerAsync(migrationListener); + } + @Override public UUID addLocalMigrationListener(MigrationListener migrationListener) { return partitionEventManager.addLocalMigrationListener(migrationListener); @@ -1238,11 +1243,6 @@ public boolean removeMigrationListener(UUID registrationId) { return partitionEventManager.removeMigrationListener(registrationId); } - @Override - public CompletableFuture addMigrationListenerAsync(MigrationListener migrationListener) { - return partitionEventManager.addMigrationListenerAsync(migrationListener); - } - @Override public CompletableFuture removeMigrationListenerAsync(UUID registrationId) { return partitionEventManager.removeMigrationListenerAsync(registrationId); diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java index 3ada36a292026..afc957f9107d8 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java @@ -44,6 +44,7 @@ import static com.hazelcast.internal.partition.IPartitionService.SERVICE_NAME; import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; +import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC_ORDER_KEY; import static com.hazelcast.internal.partition.InternalPartitionService.PARTITION_LOST_EVENT_TOPIC; import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED; import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED; @@ -94,7 +95,7 @@ public void sendMigrationProcessCompletedEvent(MigrationState state) { private void sendMigrationEvent(ReplicaMigrationEvent event) { EventService eventService = nodeEngine.getEventService(); // All migration events are sent in order. - eventService.publishEvent(SERVICE_NAME, MIGRATION_EVENT_TOPIC, event, MIGRATION_EVENT_TOPIC.hashCode()); + eventService.publishEvent(SERVICE_NAME, MIGRATION_EVENT_TOPIC, event, MIGRATION_EVENT_TOPIC_ORDER_KEY); } public UUID addMigrationListener(@Nonnull MigrationListener listener) { diff --git a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java index 406a7502c2294..600cc223024d8 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java +++ b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java @@ -19,22 +19,19 @@ import com.hazelcast.client.config.ClientConfig; import com.hazelcast.client.test.TestHazelcastFactory; import com.hazelcast.cluster.ClusterState; -import com.hazelcast.config.Config; import com.hazelcast.config.ListenerConfig; import com.hazelcast.core.HazelcastInstance; +import com.hazelcast.internal.partition.MigrationStateImpl; import com.hazelcast.internal.util.UuidUtil; import com.hazelcast.partition.MigrationListener; -import com.hazelcast.internal.partition.MigrationStateImpl; import com.hazelcast.partition.PartitionMigrationListenerTest; import com.hazelcast.partition.PartitionService; import com.hazelcast.partition.ReplicaMigrationEvent; import com.hazelcast.spi.impl.eventservice.EventRegistration; import com.hazelcast.spi.impl.eventservice.EventService; -import com.hazelcast.spi.properties.ClusterProperty; import com.hazelcast.test.HazelcastParallelClassRunner; import com.hazelcast.test.annotation.ParallelJVMTest; import com.hazelcast.test.annotation.QuickTest; -import org.hamcrest.Matchers; import org.junit.After; import org.junit.Test; import org.junit.experimental.categories.Category; @@ -42,7 +39,7 @@ import java.util.Collection; import java.util.UUID; -import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Function; import static com.hazelcast.internal.cluster.impl.AdvancedClusterStateTest.changeClusterStateEventually; import static com.hazelcast.internal.partition.IPartitionService.SERVICE_NAME; @@ -57,7 +54,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotEquals; -import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; @@ -129,7 +125,7 @@ public void testRemoveMigrationListener_whenNonExistingRegistrationId() { } @Test - public void testRemoveMigrationListener() { + public void testRemoveMigrationListener_whenExistingRegistrationId() { HazelcastInstance instance = hazelcastFactory.newHazelcastInstance(); HazelcastInstance client = hazelcastFactory.newHazelcastClient(); PartitionService clientPartitionService = client.getPartitionService(); @@ -140,79 +136,77 @@ public void testRemoveMigrationListener() { boolean removed = clientPartitionService.removeMigrationListener(registrationId); assertRegistrationsSizeEventually(instance, 0); - assertTrue(removed); HazelcastInstance hz2 = hazelcastFactory.newHazelcastInstance(); warmUpPartitions(instance, hz2); - verify(listener, never()).migrationStarted(any(MigrationStateImpl.class)); - verify(listener, never()).replicaMigrationCompleted(any(ReplicaMigrationEvent.class)); + verifyMigrationListenerNeverInvoked(listener); } @Test - public void testMigrationListenerCalledOnlyOnceWhenMigrationHappens() { - Config config = new Config(); - // even partition count to make migration count deterministic - int partitionCount = 10; - config.setProperty(ClusterProperty.PARTITION_COUNT.getName(), String.valueOf(partitionCount)); - - HazelcastInstance instance1 = hazelcastFactory.newHazelcastInstance(config); - HazelcastInstance client = hazelcastFactory.newHazelcastClient(); - warmUpPartitions(instance1); - - // Change to NO_MIGRATION to prevent repartitioning - // before 2nd member started and ready. - instance1.getCluster().changeClusterState(ClusterState.NO_MIGRATION); - - PartitionMigrationListenerTest.CountingMigrationListener migrationListener = new PartitionMigrationListenerTest.CountingMigrationListener(partitionCount); - client.getPartitionService().addMigrationListener(migrationListener); + public void testMigrationListenerInvoked_whenRegisteredByConfig() { + PartitionMigrationListenerTest.EventCollectingMigrationListener clientListener = eventCollectingMigrationListener(); - HazelcastInstance instance2 = hazelcastFactory.newHazelcastInstance(config); - - changeClusterStateEventually(instance2, ClusterState.ACTIVE); + Function clientSupplier = listener -> { + ClientConfig clientConfig = new ClientConfig().addListenerConfig(new ListenerConfig(listener)); + return hazelcastFactory.newHazelcastClient(clientConfig); + }; - waitAllForSafeState(instance2, instance1); + testMigrationListenerInvoked(clientListener, clientSupplier); + } - assertTrueEventually(() -> { - assertEquals(1, migrationListener.migrationStarted.get()); - assertEquals(1, migrationListener.migrationCompleted.get()); + @Test + public void testMigrationListenerInvoked_whenRegisteredByPartitionService() { + PartitionMigrationListenerTest.EventCollectingMigrationListener clientListener = eventCollectingMigrationListener(); - int completed = getTotal(migrationListener.replicaMigrationCompleted); - int failed = getTotal(migrationListener.replicaMigrationFailed); + Function clientSupplier = listener -> { + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + client.getPartitionService().addMigrationListener(listener); + return client; + }; - assertEquals(partitionCount, completed); - assertEquals(0, failed); - }); - - for (AtomicInteger integer : migrationListener.replicaMigrationCompleted) { - assertThat(integer.get(), Matchers.lessThanOrEqualTo(1)); - } + testMigrationListenerInvoked(clientListener, clientSupplier); } - @Test - public void testMigrationStats_whenMigrationProcessCompletes() { - HazelcastInstance hz1 = hazelcastFactory.newHazelcastInstance(); - HazelcastInstance client = hazelcastFactory.newHazelcastClient(); - warmUpPartitions(hz1); + private void testMigrationListenerInvoked(PartitionMigrationListenerTest.EventCollectingMigrationListener clientListener, + Function clientFactory) { + + HazelcastInstance instance1 = hazelcastFactory.newHazelcastInstance(); + HazelcastInstance client = clientFactory.apply(clientListener); + warmUpPartitions(instance1, client); // Change to NO_MIGRATION to prevent repartitioning // before 2nd member started and ready. - hz1.getCluster().changeClusterState(ClusterState.NO_MIGRATION); + instance1.getCluster().changeClusterState(ClusterState.NO_MIGRATION); - PartitionMigrationListenerTest.EventCollectingMigrationListener listener = new PartitionMigrationListenerTest.EventCollectingMigrationListener(); - client.getPartitionService().addMigrationListener(listener); + HazelcastInstance instance2 = hazelcastFactory.newHazelcastInstance(); - HazelcastInstance hz2 = hazelcastFactory.newHazelcastInstance(); - // Back to ACTIVE - changeClusterStateEventually(hz2, ClusterState.ACTIVE); + changeClusterStateEventually(instance2, ClusterState.ACTIVE); + waitAllForSafeState(instance2, instance1, client); + + assertRegistrationsSizeEventually(instance1, 1); + assertMigrationProcess(clientListener); + } + private void verifyMigrationListenerNeverInvoked(MigrationListener listener) { + verify(listener, never()).migrationStarted(any(MigrationStateImpl.class)); + verify(listener, never()).migrationFinished(any(MigrationStateImpl.class)); + verify(listener, never()).replicaMigrationCompleted(any(ReplicaMigrationEvent.class)); + verify(listener, never()).replicaMigrationFailed(any(ReplicaMigrationEvent.class)); + } + + private void assertMigrationProcess(PartitionMigrationListenerTest.EventCollectingMigrationListener listener) { PartitionMigrationListenerTest.MigrationEventsPack eventsPack = listener.ensureAndGetSingleEventPack(); assertMigrationProcessCompleted(eventsPack); assertMigrationProcessEventsConsistent(eventsPack); assertMigrationEventsConsistentWithResult(eventsPack); } + private PartitionMigrationListenerTest.EventCollectingMigrationListener eventCollectingMigrationListener() { + return new PartitionMigrationListenerTest.EventCollectingMigrationListener(); + } + private void assertRegistrationsSizeEventually(HazelcastInstance instance, int size) { assertTrueEventually(() -> { EventService eventService = getNode(instance).getNodeEngine().getEventService(); @@ -221,12 +215,4 @@ private void assertRegistrationsSizeEventually(HazelcastInstance instance, int s assertEquals(size, registrations.size()); }); } - - private int getTotal(AtomicInteger[] integers) { - int total = 0; - for (AtomicInteger count : integers) { - total += count.get(); - } - return total; - } } diff --git a/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java b/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java index b1e57586067f7..6df564ab590b8 100644 --- a/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java +++ b/hazelcast/src/test/java/com/hazelcast/partition/PartitionMigrationListenerTest.java @@ -362,20 +362,21 @@ public void testRemoveMigrationListener() { verify(listener, never()).replicaMigrationCompleted(any(ReplicaMigrationEvent.class)); } + @SuppressWarnings("SameParameterValue") private void assertAllLessThanOrEqual(AtomicInteger[] integers, int expected) { for (AtomicInteger integer : integers) { assertThat(integer.get(), Matchers.lessThanOrEqualTo(expected)); } } - public static final class CountingMigrationListener implements MigrationListener { + private static class CountingMigrationListener implements MigrationListener { - public final AtomicInteger migrationStarted; - public final AtomicInteger migrationCompleted; - public final AtomicInteger[] replicaMigrationCompleted; - public final AtomicInteger[] replicaMigrationFailed; + final AtomicInteger migrationStarted; + final AtomicInteger migrationCompleted; + final AtomicInteger[] replicaMigrationCompleted; + final AtomicInteger[] replicaMigrationFailed; - public CountingMigrationListener(int partitionCount) { + CountingMigrationListener(int partitionCount) { migrationStarted = new AtomicInteger(); migrationCompleted = new AtomicInteger(); replicaMigrationCompleted = new AtomicInteger[partitionCount]; @@ -411,7 +412,7 @@ public void replicaMigrationFailed(ReplicaMigrationEvent event) { // Migration events are published and processed in order in a single event thread. // So we can rely on that here... - public static final class EventCollectingMigrationListener implements MigrationListener { + public static class EventCollectingMigrationListener implements MigrationListener { final List allEventPacks = Collections.synchronizedList(new ArrayList<>()); volatile MigrationEventsPack currentEvents; @@ -459,7 +460,7 @@ void awaitEventPacksComplete(int count) { } } - public static final class MigrationEventsPack { + public static class MigrationEventsPack { public volatile MigrationState migrationProcessStarted; public volatile MigrationState migrationProcessCompleted; public final List migrationsCompleted = Collections.synchronizedList(new ArrayList<>()); From c79ff0cd62341b535022a1cab056c92014134c86 Mon Sep 17 00:00:00 2001 From: petjot Date: Fri, 30 Oct 2020 15:27:12 +0100 Subject: [PATCH 03/12] Avoid creating MigrationStateImpl --- .../task/AddMigrationListenerMessageTask.java | 31 +++++++------------ 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java index 175b0dd13d573..1a5a4ecbb73a2 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -18,14 +18,15 @@ import com.hazelcast.client.impl.protocol.ClientMessage; import com.hazelcast.client.impl.protocol.codec.ClientAddMigrationListenerCodec; +import com.hazelcast.cluster.Member; import com.hazelcast.instance.impl.Node; import com.hazelcast.internal.nio.Connection; import com.hazelcast.internal.partition.IPartitionService; import com.hazelcast.partition.MigrationListener; import com.hazelcast.partition.MigrationState; -import com.hazelcast.internal.partition.MigrationStateImpl; import com.hazelcast.partition.ReplicaMigrationEvent; +import javax.annotation.Nullable; import java.security.Permission; import java.util.UUID; import java.util.concurrent.CompletableFuture; @@ -89,31 +90,23 @@ private void sendIfAlive(ClientMessage eventMessage) { private ClientMessage encodeReplicaMigrationEvent(ReplicaMigrationEvent event) { return ClientAddMigrationListenerCodec.encodeReplicaMigrationEvent( - new MigrationStateImpl( - event.getMigrationState().getStartTime(), - event.getMigrationState().getPlannedMigrations(), - event.getMigrationState().getCompletedMigrations(), - event.getMigrationState().getTotalElapsedTime() - ), + event.getMigrationState(), event.getPartitionId(), event.getReplicaIndex(), - event.getSource() != null ? event.getSource().getUuid() : null, - event.getDestination() != null ? event.getDestination().getUuid() : null, + getMemberUuid(event.getSource()), + getMemberUuid(event.getDestination()), event.isSuccess(), event.getElapsedTime() ); } - private ClientMessage encodeMigrationEvent(MigrationState event, int partitionId) { - return ClientAddMigrationListenerCodec.encodeMigrationEvent( - new MigrationStateImpl( - event.getStartTime(), - event.getPlannedMigrations(), - event.getCompletedMigrations(), - event.getTotalElapsedTime() - ), - partitionId - ); + @Nullable + private UUID getMemberUuid(@Nullable Member source) { + return source != null ? source.getUuid() : null; + } + + private ClientMessage encodeMigrationEvent(MigrationState migrationState, int partitionId) { + return ClientAddMigrationListenerCodec.encodeMigrationEvent(migrationState, partitionId); } @Override From 048d48b66c0e99405fbf12fe18c6dc454826f408 Mon Sep 17 00:00:00 2001 From: petjot Date: Fri, 30 Oct 2020 16:32:07 +0100 Subject: [PATCH 04/12] MigrationListener since 2.2 --- .../ClientCompatibilityNullTest_2_1.java | 1676 ++-- .../ClientCompatibilityNullTest_2_2.java | 6715 +++++++++++++++ .../ClientCompatibilityTest_2_1.java | 1676 ++-- .../ClientCompatibilityTest_2_2.java | 6715 +++++++++++++++ .../MemberCompatibilityNullTest_2_1.java | 1658 ++-- .../MemberCompatibilityNullTest_2_2.java | 7552 +++++++++++++++++ .../MemberCompatibilityTest_2_1.java | 1658 ++-- .../MemberCompatibilityTest_2_2.java | 7552 +++++++++++++++++ .../2.1.protocol.compatibility.binary | Bin 49181 -> 48880 bytes .../2.1.protocol.compatibility.null.binary | Bin 42782 -> 42481 bytes .../2.2.protocol.compatibility.binary | Bin 0 -> 49181 bytes .../2.2.protocol.compatibility.null.binary | Bin 0 -> 42782 bytes 12 files changed, 31758 insertions(+), 3444 deletions(-) create mode 100644 hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_2.java create mode 100644 hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityTest_2_2.java create mode 100644 hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_2.java create mode 100644 hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_2.java create mode 100644 hazelcast/src/test/resources/2.2.protocol.compatibility.binary create mode 100644 hazelcast/src/test/resources/2.2.protocol.compatibility.null.binary diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java index d05b0b8b0af80..37773f4a2f020 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityNullTest_2_1.java @@ -384,73 +384,9 @@ 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 partitionId) { - assertTrue(isEqual(aMigrationState, migrationState)); - assertTrue(isEqual(anInt, partitionId)); - } - @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_MapPutCodec_encodeRequest() { - int fileClientMessageIndex = 43; + int fileClientMessageIndex = 37; ClientMessage encoded = MapPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -458,14 +394,14 @@ public void test_MapPutCodec_encodeRequest() { @Test public void test_MapPutCodec_decodeResponse() { - int fileClientMessageIndex = 44; + int fileClientMessageIndex = 38; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapPutCodec.decodeResponse(fromFile))); } @Test public void test_MapGetCodec_encodeRequest() { - int fileClientMessageIndex = 45; + int fileClientMessageIndex = 39; ClientMessage encoded = MapGetCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -473,14 +409,14 @@ public void test_MapGetCodec_encodeRequest() { @Test public void test_MapGetCodec_decodeResponse() { - int fileClientMessageIndex = 46; + int fileClientMessageIndex = 40; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapGetCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveCodec_encodeRequest() { - int fileClientMessageIndex = 47; + int fileClientMessageIndex = 41; ClientMessage encoded = MapRemoveCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -488,14 +424,14 @@ public void test_MapRemoveCodec_encodeRequest() { @Test public void test_MapRemoveCodec_decodeResponse() { - int fileClientMessageIndex = 48; + int fileClientMessageIndex = 42; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapRemoveCodec.decodeResponse(fromFile))); } @Test public void test_MapReplaceCodec_encodeRequest() { - int fileClientMessageIndex = 49; + int fileClientMessageIndex = 43; ClientMessage encoded = MapReplaceCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -503,14 +439,14 @@ public void test_MapReplaceCodec_encodeRequest() { @Test public void test_MapReplaceCodec_decodeResponse() { - int fileClientMessageIndex = 50; + int fileClientMessageIndex = 44; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapReplaceCodec.decodeResponse(fromFile))); } @Test public void test_MapReplaceIfSameCodec_encodeRequest() { - int fileClientMessageIndex = 51; + int fileClientMessageIndex = 45; ClientMessage encoded = MapReplaceIfSameCodec.encodeRequest(aString, aData, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -518,14 +454,14 @@ public void test_MapReplaceIfSameCodec_encodeRequest() { @Test public void test_MapReplaceIfSameCodec_decodeResponse() { - int fileClientMessageIndex = 52; + int fileClientMessageIndex = 46; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapReplaceIfSameCodec.decodeResponse(fromFile))); } @Test public void test_MapContainsKeyCodec_encodeRequest() { - int fileClientMessageIndex = 53; + int fileClientMessageIndex = 47; ClientMessage encoded = MapContainsKeyCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -533,14 +469,14 @@ public void test_MapContainsKeyCodec_encodeRequest() { @Test public void test_MapContainsKeyCodec_decodeResponse() { - int fileClientMessageIndex = 54; + int fileClientMessageIndex = 48; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapContainsKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapContainsValueCodec_encodeRequest() { - int fileClientMessageIndex = 55; + int fileClientMessageIndex = 49; ClientMessage encoded = MapContainsValueCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -548,14 +484,14 @@ public void test_MapContainsValueCodec_encodeRequest() { @Test public void test_MapContainsValueCodec_decodeResponse() { - int fileClientMessageIndex = 56; + int fileClientMessageIndex = 50; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapContainsValueCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveIfSameCodec_encodeRequest() { - int fileClientMessageIndex = 57; + int fileClientMessageIndex = 51; ClientMessage encoded = MapRemoveIfSameCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -563,14 +499,14 @@ public void test_MapRemoveIfSameCodec_encodeRequest() { @Test public void test_MapRemoveIfSameCodec_decodeResponse() { - int fileClientMessageIndex = 58; + int fileClientMessageIndex = 52; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveIfSameCodec.decodeResponse(fromFile))); } @Test public void test_MapDeleteCodec_encodeRequest() { - int fileClientMessageIndex = 59; + int fileClientMessageIndex = 53; ClientMessage encoded = MapDeleteCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -578,12 +514,12 @@ public void test_MapDeleteCodec_encodeRequest() { @Test public void test_MapDeleteCodec_decodeResponse() { - int fileClientMessageIndex = 60; + int fileClientMessageIndex = 54; } @Test public void test_MapFlushCodec_encodeRequest() { - int fileClientMessageIndex = 61; + int fileClientMessageIndex = 55; ClientMessage encoded = MapFlushCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -591,12 +527,12 @@ public void test_MapFlushCodec_encodeRequest() { @Test public void test_MapFlushCodec_decodeResponse() { - int fileClientMessageIndex = 62; + int fileClientMessageIndex = 56; } @Test public void test_MapTryRemoveCodec_encodeRequest() { - int fileClientMessageIndex = 63; + int fileClientMessageIndex = 57; ClientMessage encoded = MapTryRemoveCodec.encodeRequest(aString, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -604,14 +540,14 @@ public void test_MapTryRemoveCodec_encodeRequest() { @Test public void test_MapTryRemoveCodec_decodeResponse() { - int fileClientMessageIndex = 64; + int fileClientMessageIndex = 58; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryRemoveCodec.decodeResponse(fromFile))); } @Test public void test_MapTryPutCodec_encodeRequest() { - int fileClientMessageIndex = 65; + int fileClientMessageIndex = 59; ClientMessage encoded = MapTryPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -619,14 +555,14 @@ public void test_MapTryPutCodec_encodeRequest() { @Test public void test_MapTryPutCodec_decodeResponse() { - int fileClientMessageIndex = 66; + int fileClientMessageIndex = 60; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryPutCodec.decodeResponse(fromFile))); } @Test public void test_MapPutTransientCodec_encodeRequest() { - int fileClientMessageIndex = 67; + int fileClientMessageIndex = 61; ClientMessage encoded = MapPutTransientCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -634,12 +570,12 @@ public void test_MapPutTransientCodec_encodeRequest() { @Test public void test_MapPutTransientCodec_decodeResponse() { - int fileClientMessageIndex = 68; + int fileClientMessageIndex = 62; } @Test public void test_MapPutIfAbsentCodec_encodeRequest() { - int fileClientMessageIndex = 69; + int fileClientMessageIndex = 63; ClientMessage encoded = MapPutIfAbsentCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -647,14 +583,14 @@ public void test_MapPutIfAbsentCodec_encodeRequest() { @Test public void test_MapPutIfAbsentCodec_decodeResponse() { - int fileClientMessageIndex = 70; + int fileClientMessageIndex = 64; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapPutIfAbsentCodec.decodeResponse(fromFile))); } @Test public void test_MapSetCodec_encodeRequest() { - int fileClientMessageIndex = 71; + int fileClientMessageIndex = 65; ClientMessage encoded = MapSetCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -662,12 +598,12 @@ public void test_MapSetCodec_encodeRequest() { @Test public void test_MapSetCodec_decodeResponse() { - int fileClientMessageIndex = 72; + int fileClientMessageIndex = 66; } @Test public void test_MapLockCodec_encodeRequest() { - int fileClientMessageIndex = 73; + int fileClientMessageIndex = 67; ClientMessage encoded = MapLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -675,12 +611,12 @@ public void test_MapLockCodec_encodeRequest() { @Test public void test_MapLockCodec_decodeResponse() { - int fileClientMessageIndex = 74; + int fileClientMessageIndex = 68; } @Test public void test_MapTryLockCodec_encodeRequest() { - int fileClientMessageIndex = 75; + int fileClientMessageIndex = 69; ClientMessage encoded = MapTryLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -688,14 +624,14 @@ public void test_MapTryLockCodec_encodeRequest() { @Test public void test_MapTryLockCodec_decodeResponse() { - int fileClientMessageIndex = 76; + int fileClientMessageIndex = 70; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryLockCodec.decodeResponse(fromFile))); } @Test public void test_MapIsLockedCodec_encodeRequest() { - int fileClientMessageIndex = 77; + int fileClientMessageIndex = 71; ClientMessage encoded = MapIsLockedCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -703,14 +639,14 @@ public void test_MapIsLockedCodec_encodeRequest() { @Test public void test_MapIsLockedCodec_decodeResponse() { - int fileClientMessageIndex = 78; + int fileClientMessageIndex = 72; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapIsLockedCodec.decodeResponse(fromFile))); } @Test public void test_MapUnlockCodec_encodeRequest() { - int fileClientMessageIndex = 79; + int fileClientMessageIndex = 73; ClientMessage encoded = MapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -718,12 +654,12 @@ public void test_MapUnlockCodec_encodeRequest() { @Test public void test_MapUnlockCodec_decodeResponse() { - int fileClientMessageIndex = 80; + int fileClientMessageIndex = 74; } @Test public void test_MapAddInterceptorCodec_encodeRequest() { - int fileClientMessageIndex = 81; + int fileClientMessageIndex = 75; ClientMessage encoded = MapAddInterceptorCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -731,14 +667,14 @@ public void test_MapAddInterceptorCodec_encodeRequest() { @Test public void test_MapAddInterceptorCodec_decodeResponse() { - int fileClientMessageIndex = 82; + int fileClientMessageIndex = 76; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapAddInterceptorCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveInterceptorCodec_encodeRequest() { - int fileClientMessageIndex = 83; + int fileClientMessageIndex = 77; ClientMessage encoded = MapRemoveInterceptorCodec.encodeRequest(aString, aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -746,14 +682,14 @@ public void test_MapRemoveInterceptorCodec_encodeRequest() { @Test public void test_MapRemoveInterceptorCodec_decodeResponse() { - int fileClientMessageIndex = 84; + int fileClientMessageIndex = 78; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveInterceptorCodec.decodeResponse(fromFile))); } @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 85; + int fileClientMessageIndex = 79; ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -761,7 +697,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 86; + int fileClientMessageIndex = 80; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(fromFile))); } @@ -781,7 +717,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { - int fileClientMessageIndex = 87; + int fileClientMessageIndex = 81; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyWithPredicateCodecHandler handler = new MapAddEntryListenerToKeyWithPredicateCodecHandler(); handler.handle(fromFile); @@ -789,7 +725,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 88; + int fileClientMessageIndex = 82; ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -797,7 +733,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { @Test public void test_MapAddEntryListenerWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 89; + int fileClientMessageIndex = 83; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerWithPredicateCodec.decodeResponse(fromFile))); } @@ -817,7 +753,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { - int fileClientMessageIndex = 90; + int fileClientMessageIndex = 84; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerWithPredicateCodecHandler handler = new MapAddEntryListenerWithPredicateCodecHandler(); handler.handle(fromFile); @@ -825,7 +761,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { - int fileClientMessageIndex = 91; + int fileClientMessageIndex = 85; ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -833,7 +769,7 @@ public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { @Test public void test_MapAddEntryListenerToKeyCodec_decodeResponse() { - int fileClientMessageIndex = 92; + int fileClientMessageIndex = 86; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); } @@ -853,7 +789,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { - int fileClientMessageIndex = 93; + int fileClientMessageIndex = 87; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyCodecHandler handler = new MapAddEntryListenerToKeyCodecHandler(); handler.handle(fromFile); @@ -861,7 +797,7 @@ public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerCodec_encodeRequest() { - int fileClientMessageIndex = 94; + int fileClientMessageIndex = 88; ClientMessage encoded = MapAddEntryListenerCodec.encodeRequest(aString, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -869,7 +805,7 @@ public void test_MapAddEntryListenerCodec_encodeRequest() { @Test public void test_MapAddEntryListenerCodec_decodeResponse() { - int fileClientMessageIndex = 95; + int fileClientMessageIndex = 89; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerCodec.decodeResponse(fromFile))); } @@ -889,7 +825,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerCodec_handleEntryEvent() { - int fileClientMessageIndex = 96; + int fileClientMessageIndex = 90; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerCodecHandler handler = new MapAddEntryListenerCodecHandler(); handler.handle(fromFile); @@ -897,7 +833,7 @@ public void test_MapAddEntryListenerCodec_handleEntryEvent() { @Test public void test_MapRemoveEntryListenerCodec_encodeRequest() { - int fileClientMessageIndex = 97; + int fileClientMessageIndex = 91; ClientMessage encoded = MapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -905,14 +841,14 @@ public void test_MapRemoveEntryListenerCodec_encodeRequest() { @Test public void test_MapRemoveEntryListenerCodec_decodeResponse() { - int fileClientMessageIndex = 98; + int fileClientMessageIndex = 92; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveEntryListenerCodec.decodeResponse(fromFile))); } @Test public void test_MapAddPartitionLostListenerCodec_encodeRequest() { - int fileClientMessageIndex = 99; + int fileClientMessageIndex = 93; ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -920,7 +856,7 @@ public void test_MapAddPartitionLostListenerCodec_encodeRequest() { @Test public void test_MapAddPartitionLostListenerCodec_decodeResponse() { - int fileClientMessageIndex = 100; + int fileClientMessageIndex = 94; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddPartitionLostListenerCodec.decodeResponse(fromFile))); } @@ -935,7 +871,7 @@ public void handleMapPartitionLostEvent(int partitionId, java.util.UUID uuid) { @Test public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() { - int fileClientMessageIndex = 101; + int fileClientMessageIndex = 95; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddPartitionLostListenerCodecHandler handler = new MapAddPartitionLostListenerCodecHandler(); handler.handle(fromFile); @@ -943,7 +879,7 @@ public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() @Test public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { - int fileClientMessageIndex = 102; + int fileClientMessageIndex = 96; ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -951,14 +887,14 @@ public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { @Test public void test_MapRemovePartitionLostListenerCodec_decodeResponse() { - int fileClientMessageIndex = 103; + int fileClientMessageIndex = 97; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemovePartitionLostListenerCodec.decodeResponse(fromFile))); } @Test public void test_MapGetEntryViewCodec_encodeRequest() { - int fileClientMessageIndex = 104; + int fileClientMessageIndex = 98; ClientMessage encoded = MapGetEntryViewCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -966,7 +902,7 @@ public void test_MapGetEntryViewCodec_encodeRequest() { @Test public void test_MapGetEntryViewCodec_decodeResponse() { - int fileClientMessageIndex = 105; + int fileClientMessageIndex = 99; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetEntryViewCodec.ResponseParameters parameters = MapGetEntryViewCodec.decodeResponse(fromFile); assertTrue(isEqual(null, parameters.response)); @@ -975,7 +911,7 @@ public void test_MapGetEntryViewCodec_decodeResponse() { @Test public void test_MapEvictCodec_encodeRequest() { - int fileClientMessageIndex = 106; + int fileClientMessageIndex = 100; ClientMessage encoded = MapEvictCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -983,14 +919,14 @@ public void test_MapEvictCodec_encodeRequest() { @Test public void test_MapEvictCodec_decodeResponse() { - int fileClientMessageIndex = 107; + int fileClientMessageIndex = 101; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapEvictCodec.decodeResponse(fromFile))); } @Test public void test_MapEvictAllCodec_encodeRequest() { - int fileClientMessageIndex = 108; + int fileClientMessageIndex = 102; ClientMessage encoded = MapEvictAllCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -998,12 +934,12 @@ public void test_MapEvictAllCodec_encodeRequest() { @Test public void test_MapEvictAllCodec_decodeResponse() { - int fileClientMessageIndex = 109; + int fileClientMessageIndex = 103; } @Test public void test_MapLoadAllCodec_encodeRequest() { - int fileClientMessageIndex = 110; + int fileClientMessageIndex = 104; ClientMessage encoded = MapLoadAllCodec.encodeRequest(aString, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1011,12 +947,12 @@ public void test_MapLoadAllCodec_encodeRequest() { @Test public void test_MapLoadAllCodec_decodeResponse() { - int fileClientMessageIndex = 111; + int fileClientMessageIndex = 105; } @Test public void test_MapLoadGivenKeysCodec_encodeRequest() { - int fileClientMessageIndex = 112; + int fileClientMessageIndex = 106; ClientMessage encoded = MapLoadGivenKeysCodec.encodeRequest(aString, aListOfData, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1024,12 +960,12 @@ public void test_MapLoadGivenKeysCodec_encodeRequest() { @Test public void test_MapLoadGivenKeysCodec_decodeResponse() { - int fileClientMessageIndex = 113; + int fileClientMessageIndex = 107; } @Test public void test_MapKeySetCodec_encodeRequest() { - int fileClientMessageIndex = 114; + int fileClientMessageIndex = 108; ClientMessage encoded = MapKeySetCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1037,14 +973,14 @@ public void test_MapKeySetCodec_encodeRequest() { @Test public void test_MapKeySetCodec_decodeResponse() { - int fileClientMessageIndex = 115; + int fileClientMessageIndex = 109; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapKeySetCodec.decodeResponse(fromFile))); } @Test public void test_MapGetAllCodec_encodeRequest() { - int fileClientMessageIndex = 116; + int fileClientMessageIndex = 110; ClientMessage encoded = MapGetAllCodec.encodeRequest(aString, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1052,14 +988,14 @@ public void test_MapGetAllCodec_encodeRequest() { @Test public void test_MapGetAllCodec_decodeResponse() { - int fileClientMessageIndex = 117; + int fileClientMessageIndex = 111; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapGetAllCodec.decodeResponse(fromFile))); } @Test public void test_MapValuesCodec_encodeRequest() { - int fileClientMessageIndex = 118; + int fileClientMessageIndex = 112; ClientMessage encoded = MapValuesCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1067,14 +1003,14 @@ public void test_MapValuesCodec_encodeRequest() { @Test public void test_MapValuesCodec_decodeResponse() { - int fileClientMessageIndex = 119; + int fileClientMessageIndex = 113; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapValuesCodec.decodeResponse(fromFile))); } @Test public void test_MapEntrySetCodec_encodeRequest() { - int fileClientMessageIndex = 120; + int fileClientMessageIndex = 114; ClientMessage encoded = MapEntrySetCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1082,14 +1018,14 @@ public void test_MapEntrySetCodec_encodeRequest() { @Test public void test_MapEntrySetCodec_decodeResponse() { - int fileClientMessageIndex = 121; + int fileClientMessageIndex = 115; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapEntrySetCodec.decodeResponse(fromFile))); } @Test public void test_MapKeySetWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 122; + int fileClientMessageIndex = 116; ClientMessage encoded = MapKeySetWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1097,14 +1033,14 @@ public void test_MapKeySetWithPredicateCodec_encodeRequest() { @Test public void test_MapKeySetWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 123; + int fileClientMessageIndex = 117; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapKeySetWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapValuesWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 124; + int fileClientMessageIndex = 118; ClientMessage encoded = MapValuesWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1112,14 +1048,14 @@ public void test_MapValuesWithPredicateCodec_encodeRequest() { @Test public void test_MapValuesWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 125; + int fileClientMessageIndex = 119; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapValuesWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapEntriesWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 126; + int fileClientMessageIndex = 120; ClientMessage encoded = MapEntriesWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1127,14 +1063,14 @@ public void test_MapEntriesWithPredicateCodec_encodeRequest() { @Test public void test_MapEntriesWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 127; + int fileClientMessageIndex = 121; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapEntriesWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapAddIndexCodec_encodeRequest() { - int fileClientMessageIndex = 128; + int fileClientMessageIndex = 122; ClientMessage encoded = MapAddIndexCodec.encodeRequest(aString, anIndexConfig); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1142,12 +1078,12 @@ public void test_MapAddIndexCodec_encodeRequest() { @Test public void test_MapAddIndexCodec_decodeResponse() { - int fileClientMessageIndex = 129; + int fileClientMessageIndex = 123; } @Test public void test_MapSizeCodec_encodeRequest() { - int fileClientMessageIndex = 130; + int fileClientMessageIndex = 124; ClientMessage encoded = MapSizeCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1155,14 +1091,14 @@ public void test_MapSizeCodec_encodeRequest() { @Test public void test_MapSizeCodec_decodeResponse() { - int fileClientMessageIndex = 131; + int fileClientMessageIndex = 125; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anInt, MapSizeCodec.decodeResponse(fromFile))); } @Test public void test_MapIsEmptyCodec_encodeRequest() { - int fileClientMessageIndex = 132; + int fileClientMessageIndex = 126; ClientMessage encoded = MapIsEmptyCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1170,14 +1106,14 @@ public void test_MapIsEmptyCodec_encodeRequest() { @Test public void test_MapIsEmptyCodec_decodeResponse() { - int fileClientMessageIndex = 133; + int fileClientMessageIndex = 127; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapIsEmptyCodec.decodeResponse(fromFile))); } @Test public void test_MapPutAllCodec_encodeRequest() { - int fileClientMessageIndex = 134; + int fileClientMessageIndex = 128; ClientMessage encoded = MapPutAllCodec.encodeRequest(aString, aListOfDataToData, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1185,12 +1121,12 @@ public void test_MapPutAllCodec_encodeRequest() { @Test public void test_MapPutAllCodec_decodeResponse() { - int fileClientMessageIndex = 135; + int fileClientMessageIndex = 129; } @Test public void test_MapClearCodec_encodeRequest() { - int fileClientMessageIndex = 136; + int fileClientMessageIndex = 130; ClientMessage encoded = MapClearCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1198,12 +1134,12 @@ public void test_MapClearCodec_encodeRequest() { @Test public void test_MapClearCodec_decodeResponse() { - int fileClientMessageIndex = 137; + int fileClientMessageIndex = 131; } @Test public void test_MapExecuteOnKeyCodec_encodeRequest() { - int fileClientMessageIndex = 138; + int fileClientMessageIndex = 132; ClientMessage encoded = MapExecuteOnKeyCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1211,14 +1147,14 @@ public void test_MapExecuteOnKeyCodec_encodeRequest() { @Test public void test_MapExecuteOnKeyCodec_decodeResponse() { - int fileClientMessageIndex = 139; + int fileClientMessageIndex = 133; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapExecuteOnKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapSubmitToKeyCodec_encodeRequest() { - int fileClientMessageIndex = 140; + int fileClientMessageIndex = 134; ClientMessage encoded = MapSubmitToKeyCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1226,14 +1162,14 @@ public void test_MapSubmitToKeyCodec_encodeRequest() { @Test public void test_MapSubmitToKeyCodec_decodeResponse() { - int fileClientMessageIndex = 141; + int fileClientMessageIndex = 135; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapSubmitToKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteOnAllKeysCodec_encodeRequest() { - int fileClientMessageIndex = 142; + int fileClientMessageIndex = 136; ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1241,14 +1177,14 @@ public void test_MapExecuteOnAllKeysCodec_encodeRequest() { @Test public void test_MapExecuteOnAllKeysCodec_decodeResponse() { - int fileClientMessageIndex = 143; + int fileClientMessageIndex = 137; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteOnAllKeysCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 144; + int fileClientMessageIndex = 138; ClientMessage encoded = MapExecuteWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1256,14 +1192,14 @@ public void test_MapExecuteWithPredicateCodec_encodeRequest() { @Test public void test_MapExecuteWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 145; + int fileClientMessageIndex = 139; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteOnKeysCodec_encodeRequest() { - int fileClientMessageIndex = 146; + int fileClientMessageIndex = 140; ClientMessage encoded = MapExecuteOnKeysCodec.encodeRequest(aString, aData, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1271,14 +1207,14 @@ public void test_MapExecuteOnKeysCodec_encodeRequest() { @Test public void test_MapExecuteOnKeysCodec_decodeResponse() { - int fileClientMessageIndex = 147; + int fileClientMessageIndex = 141; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteOnKeysCodec.decodeResponse(fromFile))); } @Test public void test_MapForceUnlockCodec_encodeRequest() { - int fileClientMessageIndex = 148; + int fileClientMessageIndex = 142; ClientMessage encoded = MapForceUnlockCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1286,12 +1222,12 @@ public void test_MapForceUnlockCodec_encodeRequest() { @Test public void test_MapForceUnlockCodec_decodeResponse() { - int fileClientMessageIndex = 149; + int fileClientMessageIndex = 143; } @Test public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 150; + int fileClientMessageIndex = 144; ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1299,7 +1235,7 @@ public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 151; + int fileClientMessageIndex = 145; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapKeySetWithPagingPredicateCodec.ResponseParameters parameters = MapKeySetWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfData, parameters.response)); @@ -1308,7 +1244,7 @@ public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 152; + int fileClientMessageIndex = 146; ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1316,7 +1252,7 @@ public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 153; + int fileClientMessageIndex = 147; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapValuesWithPagingPredicateCodec.ResponseParameters parameters = MapValuesWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfData, parameters.response)); @@ -1325,7 +1261,7 @@ public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 154; + int fileClientMessageIndex = 148; ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1333,7 +1269,7 @@ public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 155; + int fileClientMessageIndex = 149; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEntriesWithPagingPredicateCodec.ResponseParameters parameters = MapEntriesWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfDataToData, parameters.response)); @@ -1342,7 +1278,7 @@ public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapFetchKeysCodec_encodeRequest() { - int fileClientMessageIndex = 156; + int fileClientMessageIndex = 150; ClientMessage encoded = MapFetchKeysCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1350,7 +1286,7 @@ public void test_MapFetchKeysCodec_encodeRequest() { @Test public void test_MapFetchKeysCodec_decodeResponse() { - int fileClientMessageIndex = 157; + int fileClientMessageIndex = 151; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchKeysCodec.ResponseParameters parameters = MapFetchKeysCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); @@ -1359,7 +1295,7 @@ public void test_MapFetchKeysCodec_decodeResponse() { @Test public void test_MapFetchEntriesCodec_encodeRequest() { - int fileClientMessageIndex = 158; + int fileClientMessageIndex = 152; ClientMessage encoded = MapFetchEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1367,7 +1303,7 @@ public void test_MapFetchEntriesCodec_encodeRequest() { @Test public void test_MapFetchEntriesCodec_decodeResponse() { - int fileClientMessageIndex = 159; + int fileClientMessageIndex = 153; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchEntriesCodec.ResponseParameters parameters = MapFetchEntriesCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); @@ -1376,7 +1312,7 @@ public void test_MapFetchEntriesCodec_decodeResponse() { @Test public void test_MapAggregateCodec_encodeRequest() { - int fileClientMessageIndex = 160; + int fileClientMessageIndex = 154; ClientMessage encoded = MapAggregateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1384,14 +1320,14 @@ public void test_MapAggregateCodec_encodeRequest() { @Test public void test_MapAggregateCodec_decodeResponse() { - int fileClientMessageIndex = 161; + int fileClientMessageIndex = 155; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapAggregateCodec.decodeResponse(fromFile))); } @Test public void test_MapAggregateWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 162; + int fileClientMessageIndex = 156; ClientMessage encoded = MapAggregateWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1399,14 +1335,14 @@ public void test_MapAggregateWithPredicateCodec_encodeRequest() { @Test public void test_MapAggregateWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 163; + int fileClientMessageIndex = 157; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(null, MapAggregateWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapProjectCodec_encodeRequest() { - int fileClientMessageIndex = 164; + int fileClientMessageIndex = 158; ClientMessage encoded = MapProjectCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1414,14 +1350,14 @@ public void test_MapProjectCodec_encodeRequest() { @Test public void test_MapProjectCodec_decodeResponse() { - int fileClientMessageIndex = 165; + int fileClientMessageIndex = 159; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapProjectCodec.decodeResponse(fromFile))); } @Test public void test_MapProjectWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 166; + int fileClientMessageIndex = 160; ClientMessage encoded = MapProjectWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1429,14 +1365,14 @@ public void test_MapProjectWithPredicateCodec_encodeRequest() { @Test public void test_MapProjectWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 167; + int fileClientMessageIndex = 161; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapProjectWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { - int fileClientMessageIndex = 168; + int fileClientMessageIndex = 162; ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1444,7 +1380,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { - int fileClientMessageIndex = 169; + int fileClientMessageIndex = 163; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchNearCacheInvalidationMetadataCodec.ResponseParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfStringToListOfIntegerToLong, parameters.namePartitionSequenceList)); @@ -1453,7 +1389,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { @Test public void test_MapRemoveAllCodec_encodeRequest() { - int fileClientMessageIndex = 170; + int fileClientMessageIndex = 164; ClientMessage encoded = MapRemoveAllCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1461,12 +1397,12 @@ public void test_MapRemoveAllCodec_encodeRequest() { @Test public void test_MapRemoveAllCodec_decodeResponse() { - int fileClientMessageIndex = 171; + int fileClientMessageIndex = 165; } @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { - int fileClientMessageIndex = 172; + int fileClientMessageIndex = 166; ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeRequest(aString, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1474,7 +1410,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_decodeResponse() { - int fileClientMessageIndex = 173; + int fileClientMessageIndex = 167; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddNearCacheInvalidationListenerCodec.decodeResponse(fromFile))); } @@ -1498,7 +1434,7 @@ public void handleIMapBatchInvalidationEvent(java.util.Collection clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.2.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 partitionId) { + assertTrue(isEqual(aMigrationState, migrationState)); + assertTrue(isEqual(anInt, partitionId)); + } + @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_MapPutCodec_encodeRequest() { + int fileClientMessageIndex = 43; + 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 = 44; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetCodec_encodeRequest() { + int fileClientMessageIndex = 45; + ClientMessage encoded = MapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeResponse() { + int fileClientMessageIndex = 46; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 47; + ClientMessage encoded = MapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 48; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 49; + ClientMessage encoded = MapReplaceCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 50; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 51; + 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 = 52; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 53; + ClientMessage encoded = MapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 54; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 55; + ClientMessage encoded = MapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 56; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 57; + ClientMessage encoded = MapRemoveIfSameCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 58; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 59; + ClientMessage encoded = MapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 60; + } + + @Test + public void test_MapFlushCodec_encodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage encoded = MapFlushCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeResponse() { + int fileClientMessageIndex = 62; + } + + @Test + public void test_MapTryRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 63; + ClientMessage encoded = MapTryRemoveCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 64; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapTryPutCodec_encodeRequest() { + int fileClientMessageIndex = 65; + 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 = 66; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientCodec_encodeRequest() { + int fileClientMessageIndex = 67; + 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 = 68; + } + + @Test + public void test_MapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 69; + 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 = 70; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetCodec_encodeRequest() { + int fileClientMessageIndex = 71; + 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 = 72; + } + + @Test + public void test_MapLockCodec_encodeRequest() { + int fileClientMessageIndex = 73; + 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 = 74; + } + + @Test + public void test_MapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 75; + 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 = 76; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 77; + ClientMessage encoded = MapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 78; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 79; + ClientMessage encoded = MapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 80; + } + + @Test + public void test_MapAddInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 81; + ClientMessage encoded = MapAddInterceptorCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 82; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapAddInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 83; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 84; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 85; + 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 = 86; + 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 = 87; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyWithPredicateCodecHandler handler = new MapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 88; + 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 = 89; + 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 = 90; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerWithPredicateCodecHandler handler = new MapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 91; + 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 = 92; + 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 = 93; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyCodecHandler handler = new MapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 94; + ClientMessage encoded = MapAddEntryListenerCodec.encodeRequest(aString, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 95; + 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 = 96; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerCodecHandler handler = new MapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 97; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 98; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 99; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 100; + 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 = 101; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddPartitionLostListenerCodecHandler handler = new MapAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 102; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 103; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetEntryViewCodec_encodeRequest() { + int fileClientMessageIndex = 104; + ClientMessage encoded = MapGetEntryViewCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeResponse() { + int fileClientMessageIndex = 105; + 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 = 106; + ClientMessage encoded = MapEvictCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeResponse() { + int fileClientMessageIndex = 107; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapEvictCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage encoded = MapEvictAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeResponse() { + int fileClientMessageIndex = 109; + } + + @Test + public void test_MapLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 110; + ClientMessage encoded = MapLoadAllCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 111; + } + + @Test + public void test_MapLoadGivenKeysCodec_encodeRequest() { + int fileClientMessageIndex = 112; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeResponse() { + int fileClientMessageIndex = 113; + } + + @Test + public void test_MapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage encoded = MapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 115; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 116; + ClientMessage encoded = MapGetAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 117; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage encoded = MapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 119; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage encoded = MapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 122; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 123; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 124; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 125; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntriesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 126; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 127; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntriesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddIndexCodec_encodeRequest() { + int fileClientMessageIndex = 128; + ClientMessage encoded = MapAddIndexCodec.encodeRequest(aString, anIndexConfig); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeResponse() { + int fileClientMessageIndex = 129; + } + + @Test + public void test_MapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage encoded = MapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage encoded = MapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 134; + ClientMessage encoded = MapPutAllCodec.encodeRequest(aString, aListOfDataToData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 135; + } + + @Test + public void test_MapClearCodec_encodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage encoded = MapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeResponse() { + int fileClientMessageIndex = 137; + } + + @Test + public void test_MapExecuteOnKeyCodec_encodeRequest() { + int fileClientMessageIndex = 138; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeResponse() { + int fileClientMessageIndex = 139; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapExecuteOnKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSubmitToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 140; + ClientMessage encoded = MapSubmitToKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 141; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapSubmitToKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 142; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 143; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnAllKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 144; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 145; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnKeysCodec_encodeRequest() { + int fileClientMessageIndex = 146; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeRequest(aString, aData, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeResponse() { + int fileClientMessageIndex = 147; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 148; + ClientMessage encoded = MapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 149; + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 150; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 151; + 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 = 152; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 153; + 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 = 154; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 155; + 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 = 156; + ClientMessage encoded = MapFetchKeysCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeResponse() { + int fileClientMessageIndex = 157; + 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 = 158; + ClientMessage encoded = MapFetchEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 159; + 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 = 160; + ClientMessage encoded = MapAggregateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeResponse() { + int fileClientMessageIndex = 161; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapAggregateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAggregateWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 162; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 163; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapAggregateWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectCodec_encodeRequest() { + int fileClientMessageIndex = 164; + ClientMessage encoded = MapProjectCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeResponse() { + int fileClientMessageIndex = 165; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 166; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 167; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 168; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 169; + 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 = 170; + ClientMessage encoded = MapRemoveAllCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 171; + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 172; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeRequest(aString, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 173; + 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 = 174; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_handleIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 175; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapFetchWithQueryCodec_encodeRequest() { + int fileClientMessageIndex = 176; + 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 = 177; + 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 = 178; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 179; + 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 = 180; + 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 = 181; + 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 = 182; + ClientMessage encoded = MapSetTtlCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeResponse() { + int fileClientMessageIndex = 183; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapSetTtlCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 184; + 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 = 185; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 186; + 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 = 187; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutTransientWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 188; + 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 = 189; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapPutIfAbsentWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 190; + 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 = 191; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MapSetWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 192; + ClientMessage encoded = MultiMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 193; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 194; + ClientMessage encoded = MultiMapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 195; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 196; + ClientMessage encoded = MultiMapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 197; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage encoded = MultiMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 199; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage encoded = MultiMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 201; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage encoded = MultiMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MultiMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 204; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 205; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 206; + ClientMessage encoded = MultiMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 207; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsEntryCodec_encodeRequest() { + int fileClientMessageIndex = 208; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeResponse() { + int fileClientMessageIndex = 209; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage encoded = MultiMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage encoded = MultiMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 213; + } + + @Test + public void test_MultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 214; + ClientMessage encoded = MultiMapValueCountCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 215; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 216; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 217; + 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 = 218; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerToKeyCodecHandler handler = new MultiMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 219; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 220; + 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 = 221; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerCodecHandler handler = new MultiMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 222; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 223; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapLockCodec_encodeRequest() { + int fileClientMessageIndex = 224; + 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 = 225; + } + + @Test + public void test_MultiMapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 226; + 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 = 227; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 228; + ClientMessage encoded = MultiMapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 229; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 230; + ClientMessage encoded = MultiMapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 231; + } + + @Test + public void test_MultiMapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 232; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 233; + } + + @Test + public void test_MultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 234; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeResponse() { + int fileClientMessageIndex = 235; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 236; + ClientMessage encoded = MultiMapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 237; + } + + @Test + public void test_MultiMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 238; + ClientMessage encoded = MultiMapPutAllCodec.encodeRequest(aString, aListOfDataToListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 239; + } + + @Test + public void test_QueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 240; + ClientMessage encoded = QueueOfferCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeResponse() { + int fileClientMessageIndex = 241; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePutCodec_encodeRequest() { + int fileClientMessageIndex = 242; + ClientMessage encoded = QueuePutCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeResponse() { + int fileClientMessageIndex = 243; + } + + @Test + public void test_QueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage encoded = QueueSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 246; + ClientMessage encoded = QueueRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 247; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 248; + ClientMessage encoded = QueuePollCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 249; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, QueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage encoded = QueueTakeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, QueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage encoded = QueuePeekCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 253; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, QueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage encoded = QueueIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage encoded = QueueDrainToCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_encodeRequest() { + int fileClientMessageIndex = 258; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeResponse() { + int fileClientMessageIndex = 259; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToMaxSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsCodec_encodeRequest() { + int fileClientMessageIndex = 260; + ClientMessage encoded = QueueContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeResponse() { + int fileClientMessageIndex = 261; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 262; + ClientMessage encoded = QueueContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 263; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 264; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 265; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 266; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 267; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage encoded = QueueClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeResponse() { + int fileClientMessageIndex = 269; + } + + @Test + public void test_QueueAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 270; + ClientMessage encoded = QueueAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 271; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 272; + ClientMessage encoded = QueueAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 273; + 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 = 274; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddListenerCodecHandler handler = new QueueAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_QueueRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 275; + ClientMessage encoded = QueueRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 276; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 277; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 278; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 279; + ClientMessage encoded = QueueIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 280; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishCodec_encodeRequest() { + int fileClientMessageIndex = 281; + ClientMessage encoded = TopicPublishCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeResponse() { + int fileClientMessageIndex = 282; + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 283; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 284; + 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 = 285; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicAddMessageListenerCodecHandler handler = new TopicAddMessageListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 286; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 287; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TopicRemoveMessageListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishAllCodec_encodeRequest() { + int fileClientMessageIndex = 288; + ClientMessage encoded = TopicPublishAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeResponse() { + int fileClientMessageIndex = 289; + } + + @Test + public void test_ListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 290; + ClientMessage encoded = ListSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 291; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsCodec_encodeRequest() { + int fileClientMessageIndex = 292; + ClientMessage encoded = ListContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeResponse() { + int fileClientMessageIndex = 293; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 294; + ClientMessage encoded = ListContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 295; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddCodec_encodeRequest() { + int fileClientMessageIndex = 296; + ClientMessage encoded = ListAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeResponse() { + int fileClientMessageIndex = 297; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 298; + ClientMessage encoded = ListRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 299; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 300; + ClientMessage encoded = ListAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 301; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 302; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 303; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 304; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 305; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage encoded = ListClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeResponse() { + int fileClientMessageIndex = 307; + } + + @Test + public void test_ListGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage encoded = ListGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 310; + ClientMessage encoded = ListAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 311; + 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 = 312; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddListenerCodecHandler handler = new ListAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ListRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 313; + ClientMessage encoded = ListRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 314; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 315; + ClientMessage encoded = ListIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 316; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 317; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeRequest(aString, anInt, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 318; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListGetCodec_encodeRequest() { + int fileClientMessageIndex = 319; + ClientMessage encoded = ListGetCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeResponse() { + int fileClientMessageIndex = 320; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ListGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSetCodec_encodeRequest() { + int fileClientMessageIndex = 321; + ClientMessage encoded = ListSetCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeResponse() { + int fileClientMessageIndex = 322; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ListSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 323; + ClientMessage encoded = ListAddWithIndexCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 324; + } + + @Test + public void test_ListRemoveWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 325; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 326; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ListRemoveWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListLastIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 327; + ClientMessage encoded = ListLastIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 328; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListLastIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 329; + ClientMessage encoded = ListIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 330; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSubCodec_encodeRequest() { + int fileClientMessageIndex = 331; + ClientMessage encoded = ListSubCodec.encodeRequest(aString, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeResponse() { + int fileClientMessageIndex = 332; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListSubCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage encoded = ListIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 334; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 335; + ClientMessage encoded = ListListIteratorCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 336; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage encoded = SetSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsCodec_encodeRequest() { + int fileClientMessageIndex = 339; + ClientMessage encoded = SetContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeResponse() { + int fileClientMessageIndex = 340; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 341; + ClientMessage encoded = SetContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 342; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddCodec_encodeRequest() { + int fileClientMessageIndex = 343; + ClientMessage encoded = SetAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeResponse() { + int fileClientMessageIndex = 344; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 345; + ClientMessage encoded = SetRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 346; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 347; + ClientMessage encoded = SetAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 348; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 349; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 350; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 351; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 352; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage encoded = SetClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeResponse() { + int fileClientMessageIndex = 354; + } + + @Test + public void test_SetGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage encoded = SetGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, SetGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 357; + ClientMessage encoded = SetAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 358; + 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 = 359; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddListenerCodecHandler handler = new SetAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_SetRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 360; + ClientMessage encoded = SetRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 361; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 362; + ClientMessage encoded = SetIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 363; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockLockCodec_encodeRequest() { + int fileClientMessageIndex = 364; + 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 = 365; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 366; + 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 = 367; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 368; + 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 = 369; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, FencedLockUnlockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_encodeRequest() { + int fileClientMessageIndex = 370; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeResponse() { + int fileClientMessageIndex = 371; + 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 = 372; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 373; + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 376; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 377; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_encodeRequest() { + int fileClientMessageIndex = 378; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeRequest(aUUID, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeResponse() { + int fileClientMessageIndex = 379; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 380; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeRequest(aString, aUUID, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 381; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ExecutorServiceSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 382; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeRequest(aString, aUUID, aData, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeResponse() { + int fileClientMessageIndex = 383; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ExecutorServiceSubmitToMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongApplyCodec_encodeRequest() { + int fileClientMessageIndex = 384; + ClientMessage encoded = AtomicLongApplyCodec.encodeRequest(aRaftGroupId, aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeResponse() { + int fileClientMessageIndex = 385; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicLongApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAlterCodec_encodeRequest() { + int fileClientMessageIndex = 386; + ClientMessage encoded = AtomicLongAlterCodec.encodeRequest(aRaftGroupId, aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeResponse() { + int fileClientMessageIndex = 387; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAlterCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAddAndGetCodec_encodeRequest() { + int fileClientMessageIndex = 388; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeResponse() { + int fileClientMessageIndex = 389; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAddAndGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 390; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 391; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicLongCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetCodec_encodeRequest() { + int fileClientMessageIndex = 392; + ClientMessage encoded = AtomicLongGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeResponse() { + int fileClientMessageIndex = 393; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndAddCodec_encodeRequest() { + int fileClientMessageIndex = 394; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeResponse() { + int fileClientMessageIndex = 395; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 396; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 397; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefApplyCodec_encodeRequest() { + int fileClientMessageIndex = 398; + 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 = 399; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicRefApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 400; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, null, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 401; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefContainsCodec_encodeRequest() { + int fileClientMessageIndex = 402; + ClientMessage encoded = AtomicRefContainsCodec.encodeRequest(aRaftGroupId, aString, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeResponse() { + int fileClientMessageIndex = 403; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefGetCodec_encodeRequest() { + int fileClientMessageIndex = 404; + ClientMessage encoded = AtomicRefGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeResponse() { + int fileClientMessageIndex = 405; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicRefGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefSetCodec_encodeRequest() { + int fileClientMessageIndex = 406; + ClientMessage encoded = AtomicRefSetCodec.encodeRequest(aRaftGroupId, aString, null, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeResponse() { + int fileClientMessageIndex = 407; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, AtomicRefSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_encodeRequest() { + int fileClientMessageIndex = 408; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeResponse() { + int fileClientMessageIndex = 409; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchTrySetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchAwaitCodec_encodeRequest() { + int fileClientMessageIndex = 410; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeRequest(aRaftGroupId, aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeResponse() { + int fileClientMessageIndex = 411; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchAwaitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchCountDownCodec_encodeRequest() { + int fileClientMessageIndex = 412; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeRequest(aRaftGroupId, aString, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeResponse() { + int fileClientMessageIndex = 413; + } + + @Test + public void test_CountDownLatchGetCountCodec_encodeRequest() { + int fileClientMessageIndex = 414; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeResponse() { + int fileClientMessageIndex = 415; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchGetRoundCodec_encodeRequest() { + int fileClientMessageIndex = 416; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeResponse() { + int fileClientMessageIndex = 417; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetRoundCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreInitCodec_encodeRequest() { + int fileClientMessageIndex = 418; + ClientMessage encoded = SemaphoreInitCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeResponse() { + int fileClientMessageIndex = 419; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreInitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAcquireCodec_encodeRequest() { + int fileClientMessageIndex = 420; + 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 = 421; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreAcquireCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreReleaseCodec_encodeRequest() { + int fileClientMessageIndex = 422; + 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 = 423; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreReleaseCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreDrainCodec_encodeRequest() { + int fileClientMessageIndex = 424; + 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 = 425; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreDrainCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreChangeCodec_encodeRequest() { + int fileClientMessageIndex = 426; + 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 = 427; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreChangeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_encodeRequest() { + int fileClientMessageIndex = 428; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeResponse() { + int fileClientMessageIndex = 429; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreAvailablePermitsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreGetSemaphoreTypeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 432; + ClientMessage encoded = ReplicatedMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 433; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ReplicatedMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ReplicatedMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 438; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 439; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 440; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 441; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 442; + ClientMessage encoded = ReplicatedMapGetCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 443; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ReplicatedMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 444; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 445; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ReplicatedMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 446; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeRequest(aString, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 447; + } + + @Test + public void test_ReplicatedMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage encoded = ReplicatedMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 449; + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 450; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 451; + 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 = 452; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 453; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 454; + 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 = 455; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 456; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 457; + 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 = 458; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 459; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 460; + 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 = 461; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerCodecHandler handler = new ReplicatedMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 462; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 463; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 464; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 465; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 468; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 469; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ReplicatedMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 470; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 471; + 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 = 472; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddNearCacheEntryListenerCodecHandler handler = new ReplicatedMapAddNearCacheEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 473; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 474; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 475; + ClientMessage encoded = TransactionalMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 476; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_encodeRequest() { + int fileClientMessageIndex = 477; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeResponse() { + int fileClientMessageIndex = 478; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapGetForUpdateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 479; + ClientMessage encoded = TransactionalMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 480; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 481; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 482; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 483; + 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 = 484; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSetCodec_encodeRequest() { + int fileClientMessageIndex = 485; + 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 = 486; + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 487; + 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 = 488; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 489; + 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 = 490; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 491; + 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 = 492; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 493; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 494; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 495; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 496; + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 497; + 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 = 498; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 499; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 500; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 501; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 502; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 503; + ClientMessage encoded = TransactionalMapValuesCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 504; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 505; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 506; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 507; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 508; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 509; + 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 = 510; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 511; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 512; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 513; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 514; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 515; + 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 = 516; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 517; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 518; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 519; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 520; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetAddCodec_encodeRequest() { + int fileClientMessageIndex = 521; + ClientMessage encoded = TransactionalSetAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeResponse() { + int fileClientMessageIndex = 522; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 523; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 524; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 525; + ClientMessage encoded = TransactionalSetSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 526; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalSetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListAddCodec_encodeRequest() { + int fileClientMessageIndex = 527; + ClientMessage encoded = TransactionalListAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeResponse() { + int fileClientMessageIndex = 528; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 529; + ClientMessage encoded = TransactionalListRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 530; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 531; + ClientMessage encoded = TransactionalListSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 532; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 533; + 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 = 534; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalQueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 535; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 536; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalQueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 537; + ClientMessage encoded = TransactionalQueuePollCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 538; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalQueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 539; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 540; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, TransactionalQueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 541; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 542; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalQueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 543; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 544; + 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 = 545; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddEntryListenerCodecHandler handler = new CacheAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheClearCodec_encodeRequest() { + int fileClientMessageIndex = 546; + ClientMessage encoded = CacheClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeResponse() { + int fileClientMessageIndex = 547; + } + + @Test + public void test_CacheRemoveAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 548; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 549; + } + + @Test + public void test_CacheRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 550; + ClientMessage encoded = CacheRemoveAllCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 551; + } + + @Test + public void test_CacheContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 552; + ClientMessage encoded = CacheContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 553; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheCreateConfigCodec_encodeRequest() { + int fileClientMessageIndex = 554; + ClientMessage encoded = CacheCreateConfigCodec.encodeRequest(aCacheConfigHolder, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeResponse() { + int fileClientMessageIndex = 555; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheCreateConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage encoded = CacheDestroyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeResponse() { + int fileClientMessageIndex = 557; + } + + @Test + public void test_CacheEntryProcessorCodec_encodeRequest() { + int fileClientMessageIndex = 558; + 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 = 559; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheEntryProcessorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 560; + ClientMessage encoded = CacheGetAllCodec.encodeRequest(aString, aListOfData, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 561; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, CacheGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 562; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeRequest(aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 563; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetAndRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 564; + 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 = 565; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetAndReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 566; + ClientMessage encoded = CacheGetConfigCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeResponse() { + int fileClientMessageIndex = 567; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetCodec_encodeRequest() { + int fileClientMessageIndex = 568; + ClientMessage encoded = CacheGetCodec.encodeRequest(aString, aData, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeResponse() { + int fileClientMessageIndex = 569; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheIterateCodec_encodeRequest() { + int fileClientMessageIndex = 570; + ClientMessage encoded = CacheIterateCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeResponse() { + int fileClientMessageIndex = 571; + 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 = 572; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeRequest(aString, aData, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeResponse() { + int fileClientMessageIndex = 573; + } + + @Test + public void test_CacheLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 574; + ClientMessage encoded = CacheLoadAllCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 575; + } + + @Test + public void test_CacheManagementConfigCodec_encodeRequest() { + int fileClientMessageIndex = 576; + ClientMessage encoded = CacheManagementConfigCodec.encodeRequest(aString, aBoolean, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeResponse() { + int fileClientMessageIndex = 577; + } + + @Test + public void test_CachePutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 578; + 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 = 579; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CachePutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutCodec_encodeRequest() { + int fileClientMessageIndex = 580; + 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 = 581; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CachePutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 582; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 583; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 584; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 585; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveInvalidationListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 586; + ClientMessage encoded = CacheRemoveCodec.encodeRequest(aString, aData, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 587; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 588; + 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 = 589; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, CacheReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage encoded = CacheSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CacheSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 592; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 593; + 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 = 594; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddPartitionLostListenerCodecHandler handler = new CacheAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 595; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 596; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutAllCodec_encodeRequest() { + int fileClientMessageIndex = 597; + ClientMessage encoded = CachePutAllCodec.encodeRequest(aString, aListOfDataToData, null, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeResponse() { + int fileClientMessageIndex = 598; + } + + @Test + public void test_CacheIterateEntriesCodec_encodeRequest() { + int fileClientMessageIndex = 599; + ClientMessage encoded = CacheIterateEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 600; + 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 = 601; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 602; + 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 = 603; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_handleCacheBatchInvalidationEvent() { + int fileClientMessageIndex = 604; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 605; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 606; + 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 = 607; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 608; + 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 = 609; + 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 = 610; + 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 = 611; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeRequest(aString, aListOfData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeResponse() { + int fileClientMessageIndex = 612; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheSetExpiryPolicyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeRequest() { + int fileClientMessageIndex = 613; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeRequest(anXid); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeResponse() { + int fileClientMessageIndex = 614; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeRequest() { + int fileClientMessageIndex = 615; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfXids, XATransactionCollectTransactionsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionFinalizeCodec_encodeRequest() { + int fileClientMessageIndex = 617; + ClientMessage encoded = XATransactionFinalizeCodec.encodeRequest(anXid, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeResponse() { + int fileClientMessageIndex = 618; + } + + @Test + public void test_XATransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 619; + ClientMessage encoded = XATransactionCommitCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 620; + } + + @Test + public void test_XATransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 621; + ClientMessage encoded = XATransactionCreateCodec.encodeRequest(anXid, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 622; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage encoded = XATransactionPrepareCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeResponse() { + int fileClientMessageIndex = 624; + } + + @Test + public void test_XATransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 625; + ClientMessage encoded = XATransactionRollbackCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 626; + } + + @Test + public void test_TransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 627; + ClientMessage encoded = TransactionCommitCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 628; + } + + @Test + public void test_TransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 629; + ClientMessage encoded = TransactionCreateCodec.encodeRequest(aLong, anInt, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 630; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, TransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 631; + ClientMessage encoded = TransactionRollbackCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 632; + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeRequest() { + int fileClientMessageIndex = 633; + 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 = 634; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ContinuousQueryPublisherCreateWithValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_encodeRequest() { + int fileClientMessageIndex = 635; + 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 = 636; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ContinuousQueryPublisherCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_encodeRequest() { + int fileClientMessageIndex = 637; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeResponse() { + int fileClientMessageIndex = 638; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryMadePublishableCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 639; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 640; + 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 = 641; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_handleQueryCacheBatchEvent() { + int fileClientMessageIndex = 642; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_encodeRequest() { + int fileClientMessageIndex = 643; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeRequest(aString, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeResponse() { + int fileClientMessageIndex = 644; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQuerySetReadCursorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_encodeRequest() { + int fileClientMessageIndex = 645; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeResponse() { + int fileClientMessageIndex = 646; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryDestroyCacheCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage encoded = RingbufferSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferTailSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 651; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 652; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferHeadSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage encoded = RingbufferCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddCodec_encodeRequest() { + int fileClientMessageIndex = 657; + ClientMessage encoded = RingbufferAddCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeResponse() { + int fileClientMessageIndex = 658; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadOneCodec_encodeRequest() { + int fileClientMessageIndex = 659; + ClientMessage encoded = RingbufferReadOneCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeResponse() { + int fileClientMessageIndex = 660; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, RingbufferReadOneCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 661; + ClientMessage encoded = RingbufferAddAllCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 662; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadManyCodec_encodeRequest() { + int fileClientMessageIndex = 663; + 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 = 664; + 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 = 665; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 666; + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, DurableExecutorIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 669; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 670; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, DurableExecutorSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_encodeRequest() { + int fileClientMessageIndex = 671; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeResponse() { + int fileClientMessageIndex = 672; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, DurableExecutorRetrieveResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 673; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 674; + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 675; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 676; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, DurableExecutorRetrieveAndDisposeResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CardinalityEstimatorAddCodec_encodeRequest() { + int fileClientMessageIndex = 677; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeResponse() { + int fileClientMessageIndex = 678; + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CardinalityEstimatorEstimateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 681; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 682; + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 683; + 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 = 684; + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 685; + 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 = 686; + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeResponse() { + int fileClientMessageIndex = 688; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfScheduledTaskHandler, ScheduledExecutorGetAllScheduledFuturesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 689; + ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 690; + 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 = 691; + ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 692; + 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 = 693; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 694; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 695; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 696; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 697; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeRequest(aString, aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 698; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 699; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeRequest(aString, aString, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 700; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 701; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 702; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 703; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 704; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 705; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 706; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 707; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 708; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 709; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 710; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ScheduledExecutorGetResultFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 711; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 712; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, ScheduledExecutorGetResultFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 713; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 714; + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 715; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 716; + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 717; + 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 = 718; + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_encodeRequest() { + int fileClientMessageIndex = 719; + 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 = 720; + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 721; + 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 = 722; + } + + @Test + public void test_DynamicConfigAddListConfigCodec_encodeRequest() { + int fileClientMessageIndex = 723; + 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 = 724; + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 725; + 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 = 726; + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 727; + 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 = 728; + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 729; + 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 = 730; + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 731; + 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 = 732; + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 733; + 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 = 734; + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 735; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeRequest(aString, anInt, anInt, anInt, null, aString, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 736; + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_encodeRequest() { + int fileClientMessageIndex = 737; + 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 = 738; + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 739; + 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); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 740; + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 741; + 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 = 742; + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeRequest() { + int fileClientMessageIndex = 743; + 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); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeResponse() { + int fileClientMessageIndex = 744; + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 745; + 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 = 746; + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_encodeRequest() { + int fileClientMessageIndex = 747; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeRequest(aString, anInt, aBoolean, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeResponse() { + int fileClientMessageIndex = 748; + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_encodeRequest() { + int fileClientMessageIndex = 749; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeResponse() { + int fileClientMessageIndex = 750; + 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 = 751; + ClientMessage encoded = PNCounterGetCodec.encodeRequest(aString, aListOfUuidToLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeResponse() { + int fileClientMessageIndex = 752; + 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 = 753; + 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 = 754; + 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 = 755; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeResponse() { + int fileClientMessageIndex = 756; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, PNCounterGetConfiguredReplicaCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeResponse() { + int fileClientMessageIndex = 758; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPGroupCreateCPGroupCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_encodeRequest() { + int fileClientMessageIndex = 759; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeRequest(aRaftGroupId, aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeResponse() { + int fileClientMessageIndex = 760; + } + + @Test + public void test_CPSessionCreateSessionCodec_encodeRequest() { + int fileClientMessageIndex = 761; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeResponse() { + int fileClientMessageIndex = 762; + 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 = 763; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeResponse() { + int fileClientMessageIndex = 764; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSessionCloseSessionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_encodeRequest() { + int fileClientMessageIndex = 765; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeResponse() { + int fileClientMessageIndex = 766; + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeRequest(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CPSessionGenerateThreadIdCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCReadMetricsCodec_encodeRequest() { + int fileClientMessageIndex = 769; + ClientMessage encoded = MCReadMetricsCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeResponse() { + int fileClientMessageIndex = 770; + 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 = 771; + ClientMessage encoded = MCChangeClusterStateCodec.encodeRequest(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeResponse() { + int fileClientMessageIndex = 772; + } + + @Test + public void test_MCGetMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage encoded = MCGetMapConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 774; + 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)); + } + + @Test + public void test_MCUpdateMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 775; + 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 = 776; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeRequest() { + int fileClientMessageIndex = 777; + ClientMessage encoded = MCGetMemberConfigCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeResponse() { + int fileClientMessageIndex = 778; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMemberConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunGcCodec_encodeRequest() { + int fileClientMessageIndex = 779; + ClientMessage encoded = MCRunGcCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeResponse() { + int fileClientMessageIndex = 780; + } + + @Test + public void test_MCGetThreadDumpCodec_encodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage encoded = MCGetThreadDumpCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetThreadDumpCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCShutdownMemberCodec_encodeRequest() { + int fileClientMessageIndex = 783; + ClientMessage encoded = MCShutdownMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeResponse() { + int fileClientMessageIndex = 784; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeRequest() { + int fileClientMessageIndex = 785; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeResponse() { + int fileClientMessageIndex = 786; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeRequest() { + int fileClientMessageIndex = 787; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeResponse() { + int fileClientMessageIndex = 788; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToString, MCGetSystemPropertiesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeRequest() { + int fileClientMessageIndex = 789; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MCGetTimedMemberStateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 791; + ClientMessage encoded = MCMatchMCConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 792; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCMatchMCConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCApplyMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 793; + ClientMessage encoded = MCApplyMCConfigCodec.encodeRequest(aString, anInt, aListOfClientBwListEntries); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 794; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 795; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 796; + 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)); + } + + @Test + public void test_MCShutdownClusterCodec_encodeRequest() { + int fileClientMessageIndex = 797; + ClientMessage encoded = MCShutdownClusterCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeResponse() { + int fileClientMessageIndex = 798; + } + + @Test + public void test_MCChangeClusterVersionCodec_encodeRequest() { + int fileClientMessageIndex = 799; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeRequest(aByte, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeResponse() { + int fileClientMessageIndex = 800; + } + + @Test + public void test_MCRunScriptCodec_encodeRequest() { + int fileClientMessageIndex = 801; + ClientMessage encoded = MCRunScriptCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeResponse() { + int fileClientMessageIndex = 802; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MCRunScriptCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunConsoleCommandCodec_encodeRequest() { + int fileClientMessageIndex = 803; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeRequest(null, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeResponse() { + int fileClientMessageIndex = 804; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCRunConsoleCommandCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_encodeRequest() { + int fileClientMessageIndex = 805; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeRequest(aString, aString, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeResponse() { + int fileClientMessageIndex = 806; + } + + @Test + public void test_MCClearWanQueuesCodec_encodeRequest() { + int fileClientMessageIndex = 807; + ClientMessage encoded = MCClearWanQueuesCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeResponse() { + int fileClientMessageIndex = 808; + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_encodeRequest() { + int fileClientMessageIndex = 809; + 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 = 810; + 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 = 811; + ClientMessage encoded = MCWanSyncMapCodec.encodeRequest(aString, aString, anInt, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeResponse() { + int fileClientMessageIndex = 812; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCWanSyncMapCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCCheckWanConsistencyCodec_encodeRequest() { + int fileClientMessageIndex = 813; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeRequest(aString, aString, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeResponse() { + int fileClientMessageIndex = 814; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(null, MCCheckWanConsistencyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPollMCEventsCodec_encodeRequest() { + int fileClientMessageIndex = 815; + ClientMessage encoded = MCPollMCEventsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfMCEvents, MCPollMCEventsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetCPMembersCodec_encodeRequest() { + int fileClientMessageIndex = 817; + ClientMessage encoded = MCGetCPMembersCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeResponse() { + int fileClientMessageIndex = 818; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfUUIDToUUID, MCGetCPMembersCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 819; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 820; + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 822; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeRequest() { + int fileClientMessageIndex = 823; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeResponse() { + int fileClientMessageIndex = 824; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeRequest() { + int fileClientMessageIndex = 825; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerPartialStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerForceStartCodec_encodeRequest() { + int fileClientMessageIndex = 827; + ClientMessage encoded = MCTriggerForceStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerForceStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 829; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 830; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 831; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 832; + } + + @Test + public void test_SqlExecuteCodec_encodeRequest() { + int fileClientMessageIndex = 833; + ClientMessage encoded = SqlExecuteCodec.encodeRequest(aString, aListOfData, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeResponse() { + int fileClientMessageIndex = 834; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecuteCodec.ResponseParameters parameters = SqlExecuteCodec.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_SqlFetchCodec_encodeRequest() { + int fileClientMessageIndex = 835; + ClientMessage encoded = SqlFetchCodec.encodeRequest(anSqlQueryId, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeResponse() { + int fileClientMessageIndex = 836; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetchCodec.ResponseParameters parameters = SqlFetchCodec.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 = 837; + ClientMessage encoded = SqlCloseCodec.encodeRequest(anSqlQueryId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeResponse() { + int fileClientMessageIndex = 838; + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 839; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 840; + 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 = 841; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddMembershipListenerCodecHandler handler = new CPSubsystemAddMembershipListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 842; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 843; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveMembershipListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 844; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 845; + 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 = 846; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddGroupAvailabilityListenerCodecHandler handler = new CPSubsystemAddGroupAvailabilityListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 847; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveGroupAvailabilityListenerCodec.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_1.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityTest_2_1.java index 1e934d0a368e5..182ee4decaeb0 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityTest_2_1.java +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/ClientCompatibilityTest_2_1.java @@ -384,73 +384,9 @@ 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 partitionId) { - assertTrue(isEqual(aMigrationState, migrationState)); - assertTrue(isEqual(anInt, partitionId)); - } - @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_MapPutCodec_encodeRequest() { - int fileClientMessageIndex = 43; + int fileClientMessageIndex = 37; ClientMessage encoded = MapPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -458,14 +394,14 @@ public void test_MapPutCodec_encodeRequest() { @Test public void test_MapPutCodec_decodeResponse() { - int fileClientMessageIndex = 44; + int fileClientMessageIndex = 38; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapPutCodec.decodeResponse(fromFile))); } @Test public void test_MapGetCodec_encodeRequest() { - int fileClientMessageIndex = 45; + int fileClientMessageIndex = 39; ClientMessage encoded = MapGetCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -473,14 +409,14 @@ public void test_MapGetCodec_encodeRequest() { @Test public void test_MapGetCodec_decodeResponse() { - int fileClientMessageIndex = 46; + int fileClientMessageIndex = 40; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapGetCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveCodec_encodeRequest() { - int fileClientMessageIndex = 47; + int fileClientMessageIndex = 41; ClientMessage encoded = MapRemoveCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -488,14 +424,14 @@ public void test_MapRemoveCodec_encodeRequest() { @Test public void test_MapRemoveCodec_decodeResponse() { - int fileClientMessageIndex = 48; + int fileClientMessageIndex = 42; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapRemoveCodec.decodeResponse(fromFile))); } @Test public void test_MapReplaceCodec_encodeRequest() { - int fileClientMessageIndex = 49; + int fileClientMessageIndex = 43; ClientMessage encoded = MapReplaceCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -503,14 +439,14 @@ public void test_MapReplaceCodec_encodeRequest() { @Test public void test_MapReplaceCodec_decodeResponse() { - int fileClientMessageIndex = 50; + int fileClientMessageIndex = 44; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapReplaceCodec.decodeResponse(fromFile))); } @Test public void test_MapReplaceIfSameCodec_encodeRequest() { - int fileClientMessageIndex = 51; + int fileClientMessageIndex = 45; ClientMessage encoded = MapReplaceIfSameCodec.encodeRequest(aString, aData, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -518,14 +454,14 @@ public void test_MapReplaceIfSameCodec_encodeRequest() { @Test public void test_MapReplaceIfSameCodec_decodeResponse() { - int fileClientMessageIndex = 52; + int fileClientMessageIndex = 46; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapReplaceIfSameCodec.decodeResponse(fromFile))); } @Test public void test_MapContainsKeyCodec_encodeRequest() { - int fileClientMessageIndex = 53; + int fileClientMessageIndex = 47; ClientMessage encoded = MapContainsKeyCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -533,14 +469,14 @@ public void test_MapContainsKeyCodec_encodeRequest() { @Test public void test_MapContainsKeyCodec_decodeResponse() { - int fileClientMessageIndex = 54; + int fileClientMessageIndex = 48; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapContainsKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapContainsValueCodec_encodeRequest() { - int fileClientMessageIndex = 55; + int fileClientMessageIndex = 49; ClientMessage encoded = MapContainsValueCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -548,14 +484,14 @@ public void test_MapContainsValueCodec_encodeRequest() { @Test public void test_MapContainsValueCodec_decodeResponse() { - int fileClientMessageIndex = 56; + int fileClientMessageIndex = 50; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapContainsValueCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveIfSameCodec_encodeRequest() { - int fileClientMessageIndex = 57; + int fileClientMessageIndex = 51; ClientMessage encoded = MapRemoveIfSameCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -563,14 +499,14 @@ public void test_MapRemoveIfSameCodec_encodeRequest() { @Test public void test_MapRemoveIfSameCodec_decodeResponse() { - int fileClientMessageIndex = 58; + int fileClientMessageIndex = 52; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveIfSameCodec.decodeResponse(fromFile))); } @Test public void test_MapDeleteCodec_encodeRequest() { - int fileClientMessageIndex = 59; + int fileClientMessageIndex = 53; ClientMessage encoded = MapDeleteCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -578,12 +514,12 @@ public void test_MapDeleteCodec_encodeRequest() { @Test public void test_MapDeleteCodec_decodeResponse() { - int fileClientMessageIndex = 60; + int fileClientMessageIndex = 54; } @Test public void test_MapFlushCodec_encodeRequest() { - int fileClientMessageIndex = 61; + int fileClientMessageIndex = 55; ClientMessage encoded = MapFlushCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -591,12 +527,12 @@ public void test_MapFlushCodec_encodeRequest() { @Test public void test_MapFlushCodec_decodeResponse() { - int fileClientMessageIndex = 62; + int fileClientMessageIndex = 56; } @Test public void test_MapTryRemoveCodec_encodeRequest() { - int fileClientMessageIndex = 63; + int fileClientMessageIndex = 57; ClientMessage encoded = MapTryRemoveCodec.encodeRequest(aString, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -604,14 +540,14 @@ public void test_MapTryRemoveCodec_encodeRequest() { @Test public void test_MapTryRemoveCodec_decodeResponse() { - int fileClientMessageIndex = 64; + int fileClientMessageIndex = 58; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryRemoveCodec.decodeResponse(fromFile))); } @Test public void test_MapTryPutCodec_encodeRequest() { - int fileClientMessageIndex = 65; + int fileClientMessageIndex = 59; ClientMessage encoded = MapTryPutCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -619,14 +555,14 @@ public void test_MapTryPutCodec_encodeRequest() { @Test public void test_MapTryPutCodec_decodeResponse() { - int fileClientMessageIndex = 66; + int fileClientMessageIndex = 60; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryPutCodec.decodeResponse(fromFile))); } @Test public void test_MapPutTransientCodec_encodeRequest() { - int fileClientMessageIndex = 67; + int fileClientMessageIndex = 61; ClientMessage encoded = MapPutTransientCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -634,12 +570,12 @@ public void test_MapPutTransientCodec_encodeRequest() { @Test public void test_MapPutTransientCodec_decodeResponse() { - int fileClientMessageIndex = 68; + int fileClientMessageIndex = 62; } @Test public void test_MapPutIfAbsentCodec_encodeRequest() { - int fileClientMessageIndex = 69; + int fileClientMessageIndex = 63; ClientMessage encoded = MapPutIfAbsentCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -647,14 +583,14 @@ public void test_MapPutIfAbsentCodec_encodeRequest() { @Test public void test_MapPutIfAbsentCodec_decodeResponse() { - int fileClientMessageIndex = 70; + int fileClientMessageIndex = 64; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapPutIfAbsentCodec.decodeResponse(fromFile))); } @Test public void test_MapSetCodec_encodeRequest() { - int fileClientMessageIndex = 71; + int fileClientMessageIndex = 65; ClientMessage encoded = MapSetCodec.encodeRequest(aString, aData, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -662,12 +598,12 @@ public void test_MapSetCodec_encodeRequest() { @Test public void test_MapSetCodec_decodeResponse() { - int fileClientMessageIndex = 72; + int fileClientMessageIndex = 66; } @Test public void test_MapLockCodec_encodeRequest() { - int fileClientMessageIndex = 73; + int fileClientMessageIndex = 67; ClientMessage encoded = MapLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -675,12 +611,12 @@ public void test_MapLockCodec_encodeRequest() { @Test public void test_MapLockCodec_decodeResponse() { - int fileClientMessageIndex = 74; + int fileClientMessageIndex = 68; } @Test public void test_MapTryLockCodec_encodeRequest() { - int fileClientMessageIndex = 75; + int fileClientMessageIndex = 69; ClientMessage encoded = MapTryLockCodec.encodeRequest(aString, aData, aLong, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -688,14 +624,14 @@ public void test_MapTryLockCodec_encodeRequest() { @Test public void test_MapTryLockCodec_decodeResponse() { - int fileClientMessageIndex = 76; + int fileClientMessageIndex = 70; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapTryLockCodec.decodeResponse(fromFile))); } @Test public void test_MapIsLockedCodec_encodeRequest() { - int fileClientMessageIndex = 77; + int fileClientMessageIndex = 71; ClientMessage encoded = MapIsLockedCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -703,14 +639,14 @@ public void test_MapIsLockedCodec_encodeRequest() { @Test public void test_MapIsLockedCodec_decodeResponse() { - int fileClientMessageIndex = 78; + int fileClientMessageIndex = 72; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapIsLockedCodec.decodeResponse(fromFile))); } @Test public void test_MapUnlockCodec_encodeRequest() { - int fileClientMessageIndex = 79; + int fileClientMessageIndex = 73; ClientMessage encoded = MapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -718,12 +654,12 @@ public void test_MapUnlockCodec_encodeRequest() { @Test public void test_MapUnlockCodec_decodeResponse() { - int fileClientMessageIndex = 80; + int fileClientMessageIndex = 74; } @Test public void test_MapAddInterceptorCodec_encodeRequest() { - int fileClientMessageIndex = 81; + int fileClientMessageIndex = 75; ClientMessage encoded = MapAddInterceptorCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -731,14 +667,14 @@ public void test_MapAddInterceptorCodec_encodeRequest() { @Test public void test_MapAddInterceptorCodec_decodeResponse() { - int fileClientMessageIndex = 82; + int fileClientMessageIndex = 76; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapAddInterceptorCodec.decodeResponse(fromFile))); } @Test public void test_MapRemoveInterceptorCodec_encodeRequest() { - int fileClientMessageIndex = 83; + int fileClientMessageIndex = 77; ClientMessage encoded = MapRemoveInterceptorCodec.encodeRequest(aString, aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -746,14 +682,14 @@ public void test_MapRemoveInterceptorCodec_encodeRequest() { @Test public void test_MapRemoveInterceptorCodec_decodeResponse() { - int fileClientMessageIndex = 84; + int fileClientMessageIndex = 78; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveInterceptorCodec.decodeResponse(fromFile))); } @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 85; + int fileClientMessageIndex = 79; ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -761,7 +697,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 86; + int fileClientMessageIndex = 80; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyWithPredicateCodec.decodeResponse(fromFile))); } @@ -781,7 +717,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { - int fileClientMessageIndex = 87; + int fileClientMessageIndex = 81; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyWithPredicateCodecHandler handler = new MapAddEntryListenerToKeyWithPredicateCodecHandler(); handler.handle(fromFile); @@ -789,7 +725,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 88; + int fileClientMessageIndex = 82; ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -797,7 +733,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { @Test public void test_MapAddEntryListenerWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 89; + int fileClientMessageIndex = 83; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerWithPredicateCodec.decodeResponse(fromFile))); } @@ -817,7 +753,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { - int fileClientMessageIndex = 90; + int fileClientMessageIndex = 84; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerWithPredicateCodecHandler handler = new MapAddEntryListenerWithPredicateCodecHandler(); handler.handle(fromFile); @@ -825,7 +761,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { - int fileClientMessageIndex = 91; + int fileClientMessageIndex = 85; ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -833,7 +769,7 @@ public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { @Test public void test_MapAddEntryListenerToKeyCodec_decodeResponse() { - int fileClientMessageIndex = 92; + int fileClientMessageIndex = 86; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerToKeyCodec.decodeResponse(fromFile))); } @@ -853,7 +789,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { - int fileClientMessageIndex = 93; + int fileClientMessageIndex = 87; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyCodecHandler handler = new MapAddEntryListenerToKeyCodecHandler(); handler.handle(fromFile); @@ -861,7 +797,7 @@ public void test_MapAddEntryListenerToKeyCodec_handleEntryEvent() { @Test public void test_MapAddEntryListenerCodec_encodeRequest() { - int fileClientMessageIndex = 94; + int fileClientMessageIndex = 88; ClientMessage encoded = MapAddEntryListenerCodec.encodeRequest(aString, aBoolean, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -869,7 +805,7 @@ public void test_MapAddEntryListenerCodec_encodeRequest() { @Test public void test_MapAddEntryListenerCodec_decodeResponse() { - int fileClientMessageIndex = 95; + int fileClientMessageIndex = 89; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddEntryListenerCodec.decodeResponse(fromFile))); } @@ -889,7 +825,7 @@ public void handleEntryEvent(com.hazelcast.internal.serialization.Data key, com. @Test public void test_MapAddEntryListenerCodec_handleEntryEvent() { - int fileClientMessageIndex = 96; + int fileClientMessageIndex = 90; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerCodecHandler handler = new MapAddEntryListenerCodecHandler(); handler.handle(fromFile); @@ -897,7 +833,7 @@ public void test_MapAddEntryListenerCodec_handleEntryEvent() { @Test public void test_MapRemoveEntryListenerCodec_encodeRequest() { - int fileClientMessageIndex = 97; + int fileClientMessageIndex = 91; ClientMessage encoded = MapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -905,14 +841,14 @@ public void test_MapRemoveEntryListenerCodec_encodeRequest() { @Test public void test_MapRemoveEntryListenerCodec_decodeResponse() { - int fileClientMessageIndex = 98; + int fileClientMessageIndex = 92; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemoveEntryListenerCodec.decodeResponse(fromFile))); } @Test public void test_MapAddPartitionLostListenerCodec_encodeRequest() { - int fileClientMessageIndex = 99; + int fileClientMessageIndex = 93; ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -920,7 +856,7 @@ public void test_MapAddPartitionLostListenerCodec_encodeRequest() { @Test public void test_MapAddPartitionLostListenerCodec_decodeResponse() { - int fileClientMessageIndex = 100; + int fileClientMessageIndex = 94; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddPartitionLostListenerCodec.decodeResponse(fromFile))); } @@ -935,7 +871,7 @@ public void handleMapPartitionLostEvent(int partitionId, java.util.UUID uuid) { @Test public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() { - int fileClientMessageIndex = 101; + int fileClientMessageIndex = 95; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddPartitionLostListenerCodecHandler handler = new MapAddPartitionLostListenerCodecHandler(); handler.handle(fromFile); @@ -943,7 +879,7 @@ public void test_MapAddPartitionLostListenerCodec_handleMapPartitionLostEvent() @Test public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { - int fileClientMessageIndex = 102; + int fileClientMessageIndex = 96; ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -951,14 +887,14 @@ public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { @Test public void test_MapRemovePartitionLostListenerCodec_decodeResponse() { - int fileClientMessageIndex = 103; + int fileClientMessageIndex = 97; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapRemovePartitionLostListenerCodec.decodeResponse(fromFile))); } @Test public void test_MapGetEntryViewCodec_encodeRequest() { - int fileClientMessageIndex = 104; + int fileClientMessageIndex = 98; ClientMessage encoded = MapGetEntryViewCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -966,7 +902,7 @@ public void test_MapGetEntryViewCodec_encodeRequest() { @Test public void test_MapGetEntryViewCodec_decodeResponse() { - int fileClientMessageIndex = 105; + int fileClientMessageIndex = 99; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetEntryViewCodec.ResponseParameters parameters = MapGetEntryViewCodec.decodeResponse(fromFile); assertTrue(isEqual(aSimpleEntryView, parameters.response)); @@ -975,7 +911,7 @@ public void test_MapGetEntryViewCodec_decodeResponse() { @Test public void test_MapEvictCodec_encodeRequest() { - int fileClientMessageIndex = 106; + int fileClientMessageIndex = 100; ClientMessage encoded = MapEvictCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -983,14 +919,14 @@ public void test_MapEvictCodec_encodeRequest() { @Test public void test_MapEvictCodec_decodeResponse() { - int fileClientMessageIndex = 107; + int fileClientMessageIndex = 101; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapEvictCodec.decodeResponse(fromFile))); } @Test public void test_MapEvictAllCodec_encodeRequest() { - int fileClientMessageIndex = 108; + int fileClientMessageIndex = 102; ClientMessage encoded = MapEvictAllCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -998,12 +934,12 @@ public void test_MapEvictAllCodec_encodeRequest() { @Test public void test_MapEvictAllCodec_decodeResponse() { - int fileClientMessageIndex = 109; + int fileClientMessageIndex = 103; } @Test public void test_MapLoadAllCodec_encodeRequest() { - int fileClientMessageIndex = 110; + int fileClientMessageIndex = 104; ClientMessage encoded = MapLoadAllCodec.encodeRequest(aString, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1011,12 +947,12 @@ public void test_MapLoadAllCodec_encodeRequest() { @Test public void test_MapLoadAllCodec_decodeResponse() { - int fileClientMessageIndex = 111; + int fileClientMessageIndex = 105; } @Test public void test_MapLoadGivenKeysCodec_encodeRequest() { - int fileClientMessageIndex = 112; + int fileClientMessageIndex = 106; ClientMessage encoded = MapLoadGivenKeysCodec.encodeRequest(aString, aListOfData, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1024,12 +960,12 @@ public void test_MapLoadGivenKeysCodec_encodeRequest() { @Test public void test_MapLoadGivenKeysCodec_decodeResponse() { - int fileClientMessageIndex = 113; + int fileClientMessageIndex = 107; } @Test public void test_MapKeySetCodec_encodeRequest() { - int fileClientMessageIndex = 114; + int fileClientMessageIndex = 108; ClientMessage encoded = MapKeySetCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1037,14 +973,14 @@ public void test_MapKeySetCodec_encodeRequest() { @Test public void test_MapKeySetCodec_decodeResponse() { - int fileClientMessageIndex = 115; + int fileClientMessageIndex = 109; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapKeySetCodec.decodeResponse(fromFile))); } @Test public void test_MapGetAllCodec_encodeRequest() { - int fileClientMessageIndex = 116; + int fileClientMessageIndex = 110; ClientMessage encoded = MapGetAllCodec.encodeRequest(aString, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1052,14 +988,14 @@ public void test_MapGetAllCodec_encodeRequest() { @Test public void test_MapGetAllCodec_decodeResponse() { - int fileClientMessageIndex = 117; + int fileClientMessageIndex = 111; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapGetAllCodec.decodeResponse(fromFile))); } @Test public void test_MapValuesCodec_encodeRequest() { - int fileClientMessageIndex = 118; + int fileClientMessageIndex = 112; ClientMessage encoded = MapValuesCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1067,14 +1003,14 @@ public void test_MapValuesCodec_encodeRequest() { @Test public void test_MapValuesCodec_decodeResponse() { - int fileClientMessageIndex = 119; + int fileClientMessageIndex = 113; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapValuesCodec.decodeResponse(fromFile))); } @Test public void test_MapEntrySetCodec_encodeRequest() { - int fileClientMessageIndex = 120; + int fileClientMessageIndex = 114; ClientMessage encoded = MapEntrySetCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1082,14 +1018,14 @@ public void test_MapEntrySetCodec_encodeRequest() { @Test public void test_MapEntrySetCodec_decodeResponse() { - int fileClientMessageIndex = 121; + int fileClientMessageIndex = 115; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapEntrySetCodec.decodeResponse(fromFile))); } @Test public void test_MapKeySetWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 122; + int fileClientMessageIndex = 116; ClientMessage encoded = MapKeySetWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1097,14 +1033,14 @@ public void test_MapKeySetWithPredicateCodec_encodeRequest() { @Test public void test_MapKeySetWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 123; + int fileClientMessageIndex = 117; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapKeySetWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapValuesWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 124; + int fileClientMessageIndex = 118; ClientMessage encoded = MapValuesWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1112,14 +1048,14 @@ public void test_MapValuesWithPredicateCodec_encodeRequest() { @Test public void test_MapValuesWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 125; + int fileClientMessageIndex = 119; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapValuesWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapEntriesWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 126; + int fileClientMessageIndex = 120; ClientMessage encoded = MapEntriesWithPredicateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1127,14 +1063,14 @@ public void test_MapEntriesWithPredicateCodec_encodeRequest() { @Test public void test_MapEntriesWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 127; + int fileClientMessageIndex = 121; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapEntriesWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapAddIndexCodec_encodeRequest() { - int fileClientMessageIndex = 128; + int fileClientMessageIndex = 122; ClientMessage encoded = MapAddIndexCodec.encodeRequest(aString, anIndexConfig); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1142,12 +1078,12 @@ public void test_MapAddIndexCodec_encodeRequest() { @Test public void test_MapAddIndexCodec_decodeResponse() { - int fileClientMessageIndex = 129; + int fileClientMessageIndex = 123; } @Test public void test_MapSizeCodec_encodeRequest() { - int fileClientMessageIndex = 130; + int fileClientMessageIndex = 124; ClientMessage encoded = MapSizeCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1155,14 +1091,14 @@ public void test_MapSizeCodec_encodeRequest() { @Test public void test_MapSizeCodec_decodeResponse() { - int fileClientMessageIndex = 131; + int fileClientMessageIndex = 125; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anInt, MapSizeCodec.decodeResponse(fromFile))); } @Test public void test_MapIsEmptyCodec_encodeRequest() { - int fileClientMessageIndex = 132; + int fileClientMessageIndex = 126; ClientMessage encoded = MapIsEmptyCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1170,14 +1106,14 @@ public void test_MapIsEmptyCodec_encodeRequest() { @Test public void test_MapIsEmptyCodec_decodeResponse() { - int fileClientMessageIndex = 133; + int fileClientMessageIndex = 127; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MapIsEmptyCodec.decodeResponse(fromFile))); } @Test public void test_MapPutAllCodec_encodeRequest() { - int fileClientMessageIndex = 134; + int fileClientMessageIndex = 128; ClientMessage encoded = MapPutAllCodec.encodeRequest(aString, aListOfDataToData, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1185,12 +1121,12 @@ public void test_MapPutAllCodec_encodeRequest() { @Test public void test_MapPutAllCodec_decodeResponse() { - int fileClientMessageIndex = 135; + int fileClientMessageIndex = 129; } @Test public void test_MapClearCodec_encodeRequest() { - int fileClientMessageIndex = 136; + int fileClientMessageIndex = 130; ClientMessage encoded = MapClearCodec.encodeRequest(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1198,12 +1134,12 @@ public void test_MapClearCodec_encodeRequest() { @Test public void test_MapClearCodec_decodeResponse() { - int fileClientMessageIndex = 137; + int fileClientMessageIndex = 131; } @Test public void test_MapExecuteOnKeyCodec_encodeRequest() { - int fileClientMessageIndex = 138; + int fileClientMessageIndex = 132; ClientMessage encoded = MapExecuteOnKeyCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1211,14 +1147,14 @@ public void test_MapExecuteOnKeyCodec_encodeRequest() { @Test public void test_MapExecuteOnKeyCodec_decodeResponse() { - int fileClientMessageIndex = 139; + int fileClientMessageIndex = 133; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapExecuteOnKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapSubmitToKeyCodec_encodeRequest() { - int fileClientMessageIndex = 140; + int fileClientMessageIndex = 134; ClientMessage encoded = MapSubmitToKeyCodec.encodeRequest(aString, aData, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1226,14 +1162,14 @@ public void test_MapSubmitToKeyCodec_encodeRequest() { @Test public void test_MapSubmitToKeyCodec_decodeResponse() { - int fileClientMessageIndex = 141; + int fileClientMessageIndex = 135; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapSubmitToKeyCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteOnAllKeysCodec_encodeRequest() { - int fileClientMessageIndex = 142; + int fileClientMessageIndex = 136; ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1241,14 +1177,14 @@ public void test_MapExecuteOnAllKeysCodec_encodeRequest() { @Test public void test_MapExecuteOnAllKeysCodec_decodeResponse() { - int fileClientMessageIndex = 143; + int fileClientMessageIndex = 137; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteOnAllKeysCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 144; + int fileClientMessageIndex = 138; ClientMessage encoded = MapExecuteWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1256,14 +1192,14 @@ public void test_MapExecuteWithPredicateCodec_encodeRequest() { @Test public void test_MapExecuteWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 145; + int fileClientMessageIndex = 139; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapExecuteOnKeysCodec_encodeRequest() { - int fileClientMessageIndex = 146; + int fileClientMessageIndex = 140; ClientMessage encoded = MapExecuteOnKeysCodec.encodeRequest(aString, aData, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1271,14 +1207,14 @@ public void test_MapExecuteOnKeysCodec_encodeRequest() { @Test public void test_MapExecuteOnKeysCodec_decodeResponse() { - int fileClientMessageIndex = 147; + int fileClientMessageIndex = 141; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfDataToData, MapExecuteOnKeysCodec.decodeResponse(fromFile))); } @Test public void test_MapForceUnlockCodec_encodeRequest() { - int fileClientMessageIndex = 148; + int fileClientMessageIndex = 142; ClientMessage encoded = MapForceUnlockCodec.encodeRequest(aString, aData, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1286,12 +1222,12 @@ public void test_MapForceUnlockCodec_encodeRequest() { @Test public void test_MapForceUnlockCodec_decodeResponse() { - int fileClientMessageIndex = 149; + int fileClientMessageIndex = 143; } @Test public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 150; + int fileClientMessageIndex = 144; ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1299,7 +1235,7 @@ public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 151; + int fileClientMessageIndex = 145; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapKeySetWithPagingPredicateCodec.ResponseParameters parameters = MapKeySetWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfData, parameters.response)); @@ -1308,7 +1244,7 @@ public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 152; + int fileClientMessageIndex = 146; ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1316,7 +1252,7 @@ public void test_MapValuesWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 153; + int fileClientMessageIndex = 147; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapValuesWithPagingPredicateCodec.ResponseParameters parameters = MapValuesWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfData, parameters.response)); @@ -1325,7 +1261,7 @@ public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 154; + int fileClientMessageIndex = 148; ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1333,7 +1269,7 @@ public void test_MapEntriesWithPagingPredicateCodec_encodeRequest() { @Test public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 155; + int fileClientMessageIndex = 149; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEntriesWithPagingPredicateCodec.ResponseParameters parameters = MapEntriesWithPagingPredicateCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfDataToData, parameters.response)); @@ -1342,7 +1278,7 @@ public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { @Test public void test_MapFetchKeysCodec_encodeRequest() { - int fileClientMessageIndex = 156; + int fileClientMessageIndex = 150; ClientMessage encoded = MapFetchKeysCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1350,7 +1286,7 @@ public void test_MapFetchKeysCodec_encodeRequest() { @Test public void test_MapFetchKeysCodec_decodeResponse() { - int fileClientMessageIndex = 157; + int fileClientMessageIndex = 151; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchKeysCodec.ResponseParameters parameters = MapFetchKeysCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); @@ -1359,7 +1295,7 @@ public void test_MapFetchKeysCodec_decodeResponse() { @Test public void test_MapFetchEntriesCodec_encodeRequest() { - int fileClientMessageIndex = 158; + int fileClientMessageIndex = 152; ClientMessage encoded = MapFetchEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1367,7 +1303,7 @@ public void test_MapFetchEntriesCodec_encodeRequest() { @Test public void test_MapFetchEntriesCodec_decodeResponse() { - int fileClientMessageIndex = 159; + int fileClientMessageIndex = 153; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchEntriesCodec.ResponseParameters parameters = MapFetchEntriesCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfIntegerToInteger, parameters.iterationPointers)); @@ -1376,7 +1312,7 @@ public void test_MapFetchEntriesCodec_decodeResponse() { @Test public void test_MapAggregateCodec_encodeRequest() { - int fileClientMessageIndex = 160; + int fileClientMessageIndex = 154; ClientMessage encoded = MapAggregateCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1384,14 +1320,14 @@ public void test_MapAggregateCodec_encodeRequest() { @Test public void test_MapAggregateCodec_decodeResponse() { - int fileClientMessageIndex = 161; + int fileClientMessageIndex = 155; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapAggregateCodec.decodeResponse(fromFile))); } @Test public void test_MapAggregateWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 162; + int fileClientMessageIndex = 156; ClientMessage encoded = MapAggregateWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1399,14 +1335,14 @@ public void test_MapAggregateWithPredicateCodec_encodeRequest() { @Test public void test_MapAggregateWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 163; + int fileClientMessageIndex = 157; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aData, MapAggregateWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapProjectCodec_encodeRequest() { - int fileClientMessageIndex = 164; + int fileClientMessageIndex = 158; ClientMessage encoded = MapProjectCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1414,14 +1350,14 @@ public void test_MapProjectCodec_encodeRequest() { @Test public void test_MapProjectCodec_decodeResponse() { - int fileClientMessageIndex = 165; + int fileClientMessageIndex = 159; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapProjectCodec.decodeResponse(fromFile))); } @Test public void test_MapProjectWithPredicateCodec_encodeRequest() { - int fileClientMessageIndex = 166; + int fileClientMessageIndex = 160; ClientMessage encoded = MapProjectWithPredicateCodec.encodeRequest(aString, aData, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1429,14 +1365,14 @@ public void test_MapProjectWithPredicateCodec_encodeRequest() { @Test public void test_MapProjectWithPredicateCodec_decodeResponse() { - int fileClientMessageIndex = 167; + int fileClientMessageIndex = 161; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aListOfData, MapProjectWithPredicateCodec.decodeResponse(fromFile))); } @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { - int fileClientMessageIndex = 168; + int fileClientMessageIndex = 162; ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1444,7 +1380,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { - int fileClientMessageIndex = 169; + int fileClientMessageIndex = 163; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchNearCacheInvalidationMetadataCodec.ResponseParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeResponse(fromFile); assertTrue(isEqual(aListOfStringToListOfIntegerToLong, parameters.namePartitionSequenceList)); @@ -1453,7 +1389,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { @Test public void test_MapRemoveAllCodec_encodeRequest() { - int fileClientMessageIndex = 170; + int fileClientMessageIndex = 164; ClientMessage encoded = MapRemoveAllCodec.encodeRequest(aString, aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1461,12 +1397,12 @@ public void test_MapRemoveAllCodec_encodeRequest() { @Test public void test_MapRemoveAllCodec_decodeResponse() { - int fileClientMessageIndex = 171; + int fileClientMessageIndex = 165; } @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { - int fileClientMessageIndex = 172; + int fileClientMessageIndex = 166; ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeRequest(aString, anInt, aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1474,7 +1410,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_decodeResponse() { - int fileClientMessageIndex = 173; + int fileClientMessageIndex = 167; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MapAddNearCacheInvalidationListenerCodec.decodeResponse(fromFile))); } @@ -1498,7 +1434,7 @@ public void handleIMapBatchInvalidationEvent(java.util.Collection clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.2.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 partitionId) { + assertTrue(isEqual(aMigrationState, migrationState)); + assertTrue(isEqual(anInt, partitionId)); + } + @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_MapPutCodec_encodeRequest() { + int fileClientMessageIndex = 43; + 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 = 44; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetCodec_encodeRequest() { + int fileClientMessageIndex = 45; + ClientMessage encoded = MapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeResponse() { + int fileClientMessageIndex = 46; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 47; + ClientMessage encoded = MapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 48; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 49; + ClientMessage encoded = MapReplaceCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeResponse() { + int fileClientMessageIndex = 50; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 51; + 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 = 52; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 53; + ClientMessage encoded = MapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 54; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 55; + ClientMessage encoded = MapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 56; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 57; + ClientMessage encoded = MapRemoveIfSameCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeResponse() { + int fileClientMessageIndex = 58; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 59; + ClientMessage encoded = MapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 60; + } + + @Test + public void test_MapFlushCodec_encodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage encoded = MapFlushCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeResponse() { + int fileClientMessageIndex = 62; + } + + @Test + public void test_MapTryRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 63; + ClientMessage encoded = MapTryRemoveCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 64; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapTryPutCodec_encodeRequest() { + int fileClientMessageIndex = 65; + 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 = 66; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientCodec_encodeRequest() { + int fileClientMessageIndex = 67; + 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 = 68; + } + + @Test + public void test_MapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 69; + 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 = 70; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetCodec_encodeRequest() { + int fileClientMessageIndex = 71; + 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 = 72; + } + + @Test + public void test_MapLockCodec_encodeRequest() { + int fileClientMessageIndex = 73; + 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 = 74; + } + + @Test + public void test_MapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 75; + 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 = 76; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 77; + ClientMessage encoded = MapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 78; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 79; + ClientMessage encoded = MapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 80; + } + + @Test + public void test_MapAddInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 81; + ClientMessage encoded = MapAddInterceptorCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 82; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapAddInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapRemoveInterceptorCodec_encodeRequest() { + int fileClientMessageIndex = 83; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeResponse() { + int fileClientMessageIndex = 84; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveInterceptorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 85; + 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 = 86; + 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 = 87; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyWithPredicateCodecHandler handler = new MapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 88; + 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 = 89; + 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 = 90; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerWithPredicateCodecHandler handler = new MapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 91; + 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 = 92; + 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 = 93; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerToKeyCodecHandler handler = new MapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 94; + ClientMessage encoded = MapAddEntryListenerCodec.encodeRequest(aString, aBoolean, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 95; + 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 = 96; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddEntryListenerCodecHandler handler = new MapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 97; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 98; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 99; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 100; + 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 = 101; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddPartitionLostListenerCodecHandler handler = new MapAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 102; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 103; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetEntryViewCodec_encodeRequest() { + int fileClientMessageIndex = 104; + ClientMessage encoded = MapGetEntryViewCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeResponse() { + int fileClientMessageIndex = 105; + 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 = 106; + ClientMessage encoded = MapEvictCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeResponse() { + int fileClientMessageIndex = 107; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapEvictCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage encoded = MapEvictAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeResponse() { + int fileClientMessageIndex = 109; + } + + @Test + public void test_MapLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 110; + ClientMessage encoded = MapLoadAllCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 111; + } + + @Test + public void test_MapLoadGivenKeysCodec_encodeRequest() { + int fileClientMessageIndex = 112; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeResponse() { + int fileClientMessageIndex = 113; + } + + @Test + public void test_MapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage encoded = MapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 115; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 116; + ClientMessage encoded = MapGetAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 117; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage encoded = MapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 119; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage encoded = MapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 122; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 123; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 124; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 125; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapEntriesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 126; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 127; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapEntriesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAddIndexCodec_encodeRequest() { + int fileClientMessageIndex = 128; + ClientMessage encoded = MapAddIndexCodec.encodeRequest(aString, anIndexConfig); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeResponse() { + int fileClientMessageIndex = 129; + } + + @Test + public void test_MapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage encoded = MapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage encoded = MapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 134; + ClientMessage encoded = MapPutAllCodec.encodeRequest(aString, aListOfDataToData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 135; + } + + @Test + public void test_MapClearCodec_encodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage encoded = MapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeResponse() { + int fileClientMessageIndex = 137; + } + + @Test + public void test_MapExecuteOnKeyCodec_encodeRequest() { + int fileClientMessageIndex = 138; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeResponse() { + int fileClientMessageIndex = 139; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapExecuteOnKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSubmitToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 140; + ClientMessage encoded = MapSubmitToKeyCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 141; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapSubmitToKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 142; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 143; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnAllKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 144; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 145; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapExecuteOnKeysCodec_encodeRequest() { + int fileClientMessageIndex = 146; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeRequest(aString, aData, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeResponse() { + int fileClientMessageIndex = 147; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MapExecuteOnKeysCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 148; + ClientMessage encoded = MapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 149; + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 150; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 151; + 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 = 152; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 153; + 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 = 154; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeRequest(aString, aPagingPredicateHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 155; + 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 = 156; + ClientMessage encoded = MapFetchKeysCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeResponse() { + int fileClientMessageIndex = 157; + 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 = 158; + ClientMessage encoded = MapFetchEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 159; + 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 = 160; + ClientMessage encoded = MapAggregateCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeResponse() { + int fileClientMessageIndex = 161; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapAggregateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapAggregateWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 162; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 163; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapAggregateWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectCodec_encodeRequest() { + int fileClientMessageIndex = 164; + ClientMessage encoded = MapProjectCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeResponse() { + int fileClientMessageIndex = 165; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapProjectWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 166; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 167; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MapProjectWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 168; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 169; + 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 = 170; + ClientMessage encoded = MapRemoveAllCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 171; + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 172; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeRequest(aString, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 173; + 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 = 174; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_handleIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 175; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MapAddNearCacheInvalidationListenerCodecHandler handler = new MapAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MapFetchWithQueryCodec_encodeRequest() { + int fileClientMessageIndex = 176; + 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 = 177; + 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 = 178; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 179; + 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 = 180; + 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 = 181; + 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 = 182; + ClientMessage encoded = MapSetTtlCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeResponse() { + int fileClientMessageIndex = 183; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MapSetTtlCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 184; + 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 = 185; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 186; + 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 = 187; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutTransientWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 188; + 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 = 189; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapPutIfAbsentWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MapSetWithMaxIdleCodec_encodeRequest() { + int fileClientMessageIndex = 190; + 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 = 191; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, MapSetWithMaxIdleCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 192; + ClientMessage encoded = MultiMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 193; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 194; + ClientMessage encoded = MultiMapGetCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 195; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 196; + ClientMessage encoded = MultiMapRemoveCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 197; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage encoded = MultiMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 199; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage encoded = MultiMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 201; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, MultiMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage encoded = MultiMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, MultiMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 204; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 205; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 206; + ClientMessage encoded = MultiMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 207; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapContainsEntryCodec_encodeRequest() { + int fileClientMessageIndex = 208; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeResponse() { + int fileClientMessageIndex = 209; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapContainsEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage encoded = MultiMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage encoded = MultiMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 213; + } + + @Test + public void test_MultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 214; + ClientMessage encoded = MultiMapValueCountCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 215; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 216; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 217; + 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 = 218; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerToKeyCodecHandler handler = new MultiMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 219; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 220; + 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 = 221; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + MultiMapAddEntryListenerCodecHandler handler = new MultiMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 222; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 223; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapLockCodec_encodeRequest() { + int fileClientMessageIndex = 224; + 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 = 225; + } + + @Test + public void test_MultiMapTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 226; + 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 = 227; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapIsLockedCodec_encodeRequest() { + int fileClientMessageIndex = 228; + ClientMessage encoded = MultiMapIsLockedCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeResponse() { + int fileClientMessageIndex = 229; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapIsLockedCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 230; + ClientMessage encoded = MultiMapUnlockCodec.encodeRequest(aString, aData, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 231; + } + + @Test + public void test_MultiMapForceUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 232; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeResponse() { + int fileClientMessageIndex = 233; + } + + @Test + public void test_MultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 234; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeResponse() { + int fileClientMessageIndex = 235; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MultiMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 236; + ClientMessage encoded = MultiMapDeleteCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 237; + } + + @Test + public void test_MultiMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 238; + ClientMessage encoded = MultiMapPutAllCodec.encodeRequest(aString, aListOfDataToListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 239; + } + + @Test + public void test_QueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 240; + ClientMessage encoded = QueueOfferCodec.encodeRequest(aString, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeResponse() { + int fileClientMessageIndex = 241; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePutCodec_encodeRequest() { + int fileClientMessageIndex = 242; + ClientMessage encoded = QueuePutCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeResponse() { + int fileClientMessageIndex = 243; + } + + @Test + public void test_QueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage encoded = QueueSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 246; + ClientMessage encoded = QueueRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 247; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 248; + ClientMessage encoded = QueuePollCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 249; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, QueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage encoded = QueueTakeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, QueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage encoded = QueuePeekCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 253; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, QueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage encoded = QueueIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage encoded = QueueDrainToCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_encodeRequest() { + int fileClientMessageIndex = 258; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeResponse() { + int fileClientMessageIndex = 259; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, QueueDrainToMaxSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsCodec_encodeRequest() { + int fileClientMessageIndex = 260; + ClientMessage encoded = QueueContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeResponse() { + int fileClientMessageIndex = 261; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 262; + ClientMessage encoded = QueueContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 263; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 264; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 265; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 266; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 267; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage encoded = QueueClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeResponse() { + int fileClientMessageIndex = 269; + } + + @Test + public void test_QueueAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 270; + ClientMessage encoded = QueueAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 271; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 272; + ClientMessage encoded = QueueAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 273; + 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 = 274; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + QueueAddListenerCodecHandler handler = new QueueAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_QueueRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 275; + ClientMessage encoded = QueueRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 276; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 277; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 278; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, QueueRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 279; + ClientMessage encoded = QueueIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 280; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, QueueIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishCodec_encodeRequest() { + int fileClientMessageIndex = 281; + ClientMessage encoded = TopicPublishCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeResponse() { + int fileClientMessageIndex = 282; + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 283; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 284; + 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 = 285; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + TopicAddMessageListenerCodecHandler handler = new TopicAddMessageListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_encodeRequest() { + int fileClientMessageIndex = 286; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeResponse() { + int fileClientMessageIndex = 287; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TopicRemoveMessageListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TopicPublishAllCodec_encodeRequest() { + int fileClientMessageIndex = 288; + ClientMessage encoded = TopicPublishAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeResponse() { + int fileClientMessageIndex = 289; + } + + @Test + public void test_ListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 290; + ClientMessage encoded = ListSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 291; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsCodec_encodeRequest() { + int fileClientMessageIndex = 292; + ClientMessage encoded = ListContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeResponse() { + int fileClientMessageIndex = 293; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 294; + ClientMessage encoded = ListContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 295; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddCodec_encodeRequest() { + int fileClientMessageIndex = 296; + ClientMessage encoded = ListAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeResponse() { + int fileClientMessageIndex = 297; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 298; + ClientMessage encoded = ListRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 299; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 300; + ClientMessage encoded = ListAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 301; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 302; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 303; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 304; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 305; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage encoded = ListClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeResponse() { + int fileClientMessageIndex = 307; + } + + @Test + public void test_ListGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage encoded = ListGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 310; + ClientMessage encoded = ListAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 311; + 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 = 312; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ListAddListenerCodecHandler handler = new ListAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ListRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 313; + ClientMessage encoded = ListRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 314; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 315; + ClientMessage encoded = ListIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 316; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddAllWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 317; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeRequest(aString, anInt, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 318; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ListAddAllWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListGetCodec_encodeRequest() { + int fileClientMessageIndex = 319; + ClientMessage encoded = ListGetCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeResponse() { + int fileClientMessageIndex = 320; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ListGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSetCodec_encodeRequest() { + int fileClientMessageIndex = 321; + ClientMessage encoded = ListSetCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeResponse() { + int fileClientMessageIndex = 322; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ListSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListAddWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 323; + ClientMessage encoded = ListAddWithIndexCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 324; + } + + @Test + public void test_ListRemoveWithIndexCodec_encodeRequest() { + int fileClientMessageIndex = 325; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeResponse() { + int fileClientMessageIndex = 326; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ListRemoveWithIndexCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListLastIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 327; + ClientMessage encoded = ListLastIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 328; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListLastIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIndexOfCodec_encodeRequest() { + int fileClientMessageIndex = 329; + ClientMessage encoded = ListIndexOfCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeResponse() { + int fileClientMessageIndex = 330; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ListIndexOfCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListSubCodec_encodeRequest() { + int fileClientMessageIndex = 331; + ClientMessage encoded = ListSubCodec.encodeRequest(aString, anInt, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeResponse() { + int fileClientMessageIndex = 332; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListSubCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage encoded = ListIteratorCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 334; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ListListIteratorCodec_encodeRequest() { + int fileClientMessageIndex = 335; + ClientMessage encoded = ListListIteratorCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeResponse() { + int fileClientMessageIndex = 336; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ListListIteratorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage encoded = SetSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsCodec_encodeRequest() { + int fileClientMessageIndex = 339; + ClientMessage encoded = SetContainsCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeResponse() { + int fileClientMessageIndex = 340; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetContainsAllCodec_encodeRequest() { + int fileClientMessageIndex = 341; + ClientMessage encoded = SetContainsAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeResponse() { + int fileClientMessageIndex = 342; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetContainsAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddCodec_encodeRequest() { + int fileClientMessageIndex = 343; + ClientMessage encoded = SetAddCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeResponse() { + int fileClientMessageIndex = 344; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 345; + ClientMessage encoded = SetRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 346; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 347; + ClientMessage encoded = SetAddAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 348; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 349; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 350; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRemoveAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetCompareAndRetainAllCodec_encodeRequest() { + int fileClientMessageIndex = 351; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeRequest(aString, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeResponse() { + int fileClientMessageIndex = 352; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetCompareAndRetainAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage encoded = SetClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeResponse() { + int fileClientMessageIndex = 354; + } + + @Test + public void test_SetGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage encoded = SetGetAllCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, SetGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 357; + ClientMessage encoded = SetAddListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 358; + 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 = 359; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SetAddListenerCodecHandler handler = new SetAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_SetRemoveListenerCodec_encodeRequest() { + int fileClientMessageIndex = 360; + ClientMessage encoded = SetRemoveListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeResponse() { + int fileClientMessageIndex = 361; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetRemoveListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 362; + ClientMessage encoded = SetIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 363; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SetIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockLockCodec_encodeRequest() { + int fileClientMessageIndex = 364; + 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 = 365; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockTryLockCodec_encodeRequest() { + int fileClientMessageIndex = 366; + 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 = 367; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, FencedLockTryLockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockUnlockCodec_encodeRequest() { + int fileClientMessageIndex = 368; + 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 = 369; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, FencedLockUnlockCodec.decodeResponse(fromFile))); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_encodeRequest() { + int fileClientMessageIndex = 370; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeResponse() { + int fileClientMessageIndex = 371; + 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 = 372; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 373; + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 376; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 377; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_encodeRequest() { + int fileClientMessageIndex = 378; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeRequest(aUUID, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeResponse() { + int fileClientMessageIndex = 379; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ExecutorServiceCancelOnMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 380; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeRequest(aString, aUUID, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 381; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ExecutorServiceSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 382; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeRequest(aString, aUUID, aData, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeResponse() { + int fileClientMessageIndex = 383; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ExecutorServiceSubmitToMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongApplyCodec_encodeRequest() { + int fileClientMessageIndex = 384; + ClientMessage encoded = AtomicLongApplyCodec.encodeRequest(aRaftGroupId, aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeResponse() { + int fileClientMessageIndex = 385; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicLongApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAlterCodec_encodeRequest() { + int fileClientMessageIndex = 386; + ClientMessage encoded = AtomicLongAlterCodec.encodeRequest(aRaftGroupId, aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeResponse() { + int fileClientMessageIndex = 387; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAlterCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongAddAndGetCodec_encodeRequest() { + int fileClientMessageIndex = 388; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeResponse() { + int fileClientMessageIndex = 389; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongAddAndGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 390; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 391; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicLongCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetCodec_encodeRequest() { + int fileClientMessageIndex = 392; + ClientMessage encoded = AtomicLongGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeResponse() { + int fileClientMessageIndex = 393; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndAddCodec_encodeRequest() { + int fileClientMessageIndex = 394; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeResponse() { + int fileClientMessageIndex = 395; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicLongGetAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 396; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeRequest(aRaftGroupId, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 397; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, AtomicLongGetAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefApplyCodec_encodeRequest() { + int fileClientMessageIndex = 398; + 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 = 399; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicRefApplyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_encodeRequest() { + int fileClientMessageIndex = 400; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeRequest(aRaftGroupId, aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeResponse() { + int fileClientMessageIndex = 401; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefCompareAndSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefContainsCodec_encodeRequest() { + int fileClientMessageIndex = 402; + ClientMessage encoded = AtomicRefContainsCodec.encodeRequest(aRaftGroupId, aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeResponse() { + int fileClientMessageIndex = 403; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, AtomicRefContainsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefGetCodec_encodeRequest() { + int fileClientMessageIndex = 404; + ClientMessage encoded = AtomicRefGetCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeResponse() { + int fileClientMessageIndex = 405; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicRefGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_AtomicRefSetCodec_encodeRequest() { + int fileClientMessageIndex = 406; + ClientMessage encoded = AtomicRefSetCodec.encodeRequest(aRaftGroupId, aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeResponse() { + int fileClientMessageIndex = 407; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, AtomicRefSetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_encodeRequest() { + int fileClientMessageIndex = 408; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeResponse() { + int fileClientMessageIndex = 409; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchTrySetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchAwaitCodec_encodeRequest() { + int fileClientMessageIndex = 410; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeRequest(aRaftGroupId, aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeResponse() { + int fileClientMessageIndex = 411; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CountDownLatchAwaitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchCountDownCodec_encodeRequest() { + int fileClientMessageIndex = 412; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeRequest(aRaftGroupId, aString, aUUID, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeResponse() { + int fileClientMessageIndex = 413; + } + + @Test + public void test_CountDownLatchGetCountCodec_encodeRequest() { + int fileClientMessageIndex = 414; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeResponse() { + int fileClientMessageIndex = 415; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CountDownLatchGetRoundCodec_encodeRequest() { + int fileClientMessageIndex = 416; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeResponse() { + int fileClientMessageIndex = 417; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CountDownLatchGetRoundCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreInitCodec_encodeRequest() { + int fileClientMessageIndex = 418; + ClientMessage encoded = SemaphoreInitCodec.encodeRequest(aRaftGroupId, aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeResponse() { + int fileClientMessageIndex = 419; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreInitCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAcquireCodec_encodeRequest() { + int fileClientMessageIndex = 420; + 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 = 421; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreAcquireCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreReleaseCodec_encodeRequest() { + int fileClientMessageIndex = 422; + 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 = 423; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreReleaseCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreDrainCodec_encodeRequest() { + int fileClientMessageIndex = 424; + 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 = 425; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreDrainCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreChangeCodec_encodeRequest() { + int fileClientMessageIndex = 426; + 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 = 427; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreChangeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_encodeRequest() { + int fileClientMessageIndex = 428; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeResponse() { + int fileClientMessageIndex = 429; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, SemaphoreAvailablePermitsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, SemaphoreGetSemaphoreTypeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 432; + ClientMessage encoded = ReplicatedMapPutCodec.encodeRequest(aString, aData, aData, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeResponse() { + int fileClientMessageIndex = 433; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ReplicatedMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, ReplicatedMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 438; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 439; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 440; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 441; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 442; + ClientMessage encoded = ReplicatedMapGetCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 443; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ReplicatedMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 444; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 445; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ReplicatedMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapPutAllCodec_encodeRequest() { + int fileClientMessageIndex = 446; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeRequest(aString, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeResponse() { + int fileClientMessageIndex = 447; + } + + @Test + public void test_ReplicatedMapClearCodec_encodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage encoded = ReplicatedMapClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeResponse() { + int fileClientMessageIndex = 449; + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 450; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeRequest(aString, aData, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 451; + 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 = 452; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 453; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 454; + 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 = 455; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerWithPredicateCodecHandler handler = new ReplicatedMapAddEntryListenerWithPredicateCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeRequest() { + int fileClientMessageIndex = 456; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeRequest(aString, aData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeResponse() { + int fileClientMessageIndex = 457; + 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 = 458; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerToKeyCodecHandler handler = new ReplicatedMapAddEntryListenerToKeyCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 459; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 460; + 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 = 461; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddEntryListenerCodecHandler handler = new ReplicatedMapAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 462; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 463; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ReplicatedMapRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 464; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 465; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ReplicatedMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeRequest() { + int fileClientMessageIndex = 468; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeResponse() { + int fileClientMessageIndex = 469; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ReplicatedMapEntrySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 470; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeRequest(aString, aBoolean, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 471; + 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 = 472; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ReplicatedMapAddNearCacheEntryListenerCodecHandler handler = new ReplicatedMapAddNearCacheEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 473; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 474; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 475; + ClientMessage encoded = TransactionalMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 476; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_encodeRequest() { + int fileClientMessageIndex = 477; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeResponse() { + int fileClientMessageIndex = 478; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapGetForUpdateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 479; + ClientMessage encoded = TransactionalMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 480; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_encodeRequest() { + int fileClientMessageIndex = 481; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeResponse() { + int fileClientMessageIndex = 482; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapIsEmptyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 483; + 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 = 484; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapSetCodec_encodeRequest() { + int fileClientMessageIndex = 485; + 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 = 486; + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 487; + 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 = 488; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapPutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 489; + 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 = 490; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 491; + 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 = 492; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapReplaceIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 493; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 494; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapDeleteCodec_encodeRequest() { + int fileClientMessageIndex = 495; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeResponse() { + int fileClientMessageIndex = 496; + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_encodeRequest() { + int fileClientMessageIndex = 497; + 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 = 498; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapRemoveIfSameCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetCodec_encodeRequest() { + int fileClientMessageIndex = 499; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeResponse() { + int fileClientMessageIndex = 500; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 501; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 502; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapKeySetWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesCodec_encodeRequest() { + int fileClientMessageIndex = 503; + ClientMessage encoded = TransactionalMapValuesCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeResponse() { + int fileClientMessageIndex = 504; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_encodeRequest() { + int fileClientMessageIndex = 505; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeResponse() { + int fileClientMessageIndex = 506; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMapValuesWithPredicateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMapContainsValueCodec_encodeRequest() { + int fileClientMessageIndex = 507; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeResponse() { + int fileClientMessageIndex = 508; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMapContainsValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapPutCodec_encodeRequest() { + int fileClientMessageIndex = 509; + 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 = 510; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapPutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapGetCodec_encodeRequest() { + int fileClientMessageIndex = 511; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeResponse() { + int fileClientMessageIndex = 512; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 513; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 514; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, TransactionalMultiMapRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_encodeRequest() { + int fileClientMessageIndex = 515; + 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 = 516; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalMultiMapRemoveEntryCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_encodeRequest() { + int fileClientMessageIndex = 517; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeResponse() { + int fileClientMessageIndex = 518; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapValueCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_encodeRequest() { + int fileClientMessageIndex = 519; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeResponse() { + int fileClientMessageIndex = 520; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalMultiMapSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetAddCodec_encodeRequest() { + int fileClientMessageIndex = 521; + ClientMessage encoded = TransactionalSetAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeResponse() { + int fileClientMessageIndex = 522; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 523; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 524; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalSetRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalSetSizeCodec_encodeRequest() { + int fileClientMessageIndex = 525; + ClientMessage encoded = TransactionalSetSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeResponse() { + int fileClientMessageIndex = 526; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalSetSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListAddCodec_encodeRequest() { + int fileClientMessageIndex = 527; + ClientMessage encoded = TransactionalListAddCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeResponse() { + int fileClientMessageIndex = 528; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 529; + ClientMessage encoded = TransactionalListRemoveCodec.encodeRequest(aString, aUUID, aLong, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 530; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalListRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalListSizeCodec_encodeRequest() { + int fileClientMessageIndex = 531; + ClientMessage encoded = TransactionalListSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeResponse() { + int fileClientMessageIndex = 532; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalListSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueOfferCodec_encodeRequest() { + int fileClientMessageIndex = 533; + 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 = 534; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, TransactionalQueueOfferCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueTakeCodec_encodeRequest() { + int fileClientMessageIndex = 535; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeResponse() { + int fileClientMessageIndex = 536; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalQueueTakeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePollCodec_encodeRequest() { + int fileClientMessageIndex = 537; + ClientMessage encoded = TransactionalQueuePollCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeResponse() { + int fileClientMessageIndex = 538; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalQueuePollCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueuePeekCodec_encodeRequest() { + int fileClientMessageIndex = 539; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeRequest(aString, aUUID, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeResponse() { + int fileClientMessageIndex = 540; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, TransactionalQueuePeekCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionalQueueSizeCodec_encodeRequest() { + int fileClientMessageIndex = 541; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeRequest(aString, aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeResponse() { + int fileClientMessageIndex = 542; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, TransactionalQueueSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 543; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 544; + 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 = 545; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddEntryListenerCodecHandler handler = new CacheAddEntryListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheClearCodec_encodeRequest() { + int fileClientMessageIndex = 546; + ClientMessage encoded = CacheClearCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeResponse() { + int fileClientMessageIndex = 547; + } + + @Test + public void test_CacheRemoveAllKeysCodec_encodeRequest() { + int fileClientMessageIndex = 548; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeResponse() { + int fileClientMessageIndex = 549; + } + + @Test + public void test_CacheRemoveAllCodec_encodeRequest() { + int fileClientMessageIndex = 550; + ClientMessage encoded = CacheRemoveAllCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeResponse() { + int fileClientMessageIndex = 551; + } + + @Test + public void test_CacheContainsKeyCodec_encodeRequest() { + int fileClientMessageIndex = 552; + ClientMessage encoded = CacheContainsKeyCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeResponse() { + int fileClientMessageIndex = 553; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheContainsKeyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheCreateConfigCodec_encodeRequest() { + int fileClientMessageIndex = 554; + ClientMessage encoded = CacheCreateConfigCodec.encodeRequest(aCacheConfigHolder, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeResponse() { + int fileClientMessageIndex = 555; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aCacheConfigHolder, CacheCreateConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage encoded = CacheDestroyCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeResponse() { + int fileClientMessageIndex = 557; + } + + @Test + public void test_CacheEntryProcessorCodec_encodeRequest() { + int fileClientMessageIndex = 558; + 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 = 559; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheEntryProcessorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAllCodec_encodeRequest() { + int fileClientMessageIndex = 560; + ClientMessage encoded = CacheGetAllCodec.encodeRequest(aString, aListOfData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeResponse() { + int fileClientMessageIndex = 561; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, CacheGetAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 562; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeRequest(aString, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 563; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheGetAndRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetAndReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 564; + 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 = 565; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheGetAndReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 566; + ClientMessage encoded = CacheGetConfigCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeResponse() { + int fileClientMessageIndex = 567; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aCacheConfigHolder, CacheGetConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheGetCodec_encodeRequest() { + int fileClientMessageIndex = 568; + ClientMessage encoded = CacheGetCodec.encodeRequest(aString, aData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeResponse() { + int fileClientMessageIndex = 569; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheGetCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheIterateCodec_encodeRequest() { + int fileClientMessageIndex = 570; + ClientMessage encoded = CacheIterateCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeResponse() { + int fileClientMessageIndex = 571; + 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 = 572; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeRequest(aString, aData, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeResponse() { + int fileClientMessageIndex = 573; + } + + @Test + public void test_CacheLoadAllCodec_encodeRequest() { + int fileClientMessageIndex = 574; + ClientMessage encoded = CacheLoadAllCodec.encodeRequest(aString, aListOfData, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeResponse() { + int fileClientMessageIndex = 575; + } + + @Test + public void test_CacheManagementConfigCodec_encodeRequest() { + int fileClientMessageIndex = 576; + ClientMessage encoded = CacheManagementConfigCodec.encodeRequest(aString, aBoolean, aBoolean, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeResponse() { + int fileClientMessageIndex = 577; + } + + @Test + public void test_CachePutIfAbsentCodec_encodeRequest() { + int fileClientMessageIndex = 578; + 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 = 579; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CachePutIfAbsentCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutCodec_encodeRequest() { + int fileClientMessageIndex = 580; + 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 = 581; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CachePutCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_encodeRequest() { + int fileClientMessageIndex = 582; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeResponse() { + int fileClientMessageIndex = 583; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveEntryListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_encodeRequest() { + int fileClientMessageIndex = 584; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 585; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveInvalidationListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheRemoveCodec_encodeRequest() { + int fileClientMessageIndex = 586; + ClientMessage encoded = CacheRemoveCodec.encodeRequest(aString, aData, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeResponse() { + int fileClientMessageIndex = 587; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemoveCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheReplaceCodec_encodeRequest() { + int fileClientMessageIndex = 588; + 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 = 589; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, CacheReplaceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage encoded = CacheSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, CacheSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 592; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 593; + 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 = 594; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddPartitionLostListenerCodecHandler handler = new CacheAddPartitionLostListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_encodeRequest() { + int fileClientMessageIndex = 595; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeResponse() { + int fileClientMessageIndex = 596; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheRemovePartitionLostListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CachePutAllCodec_encodeRequest() { + int fileClientMessageIndex = 597; + ClientMessage encoded = CachePutAllCodec.encodeRequest(aString, aListOfDataToData, aData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeResponse() { + int fileClientMessageIndex = 598; + } + + @Test + public void test_CacheIterateEntriesCodec_encodeRequest() { + int fileClientMessageIndex = 599; + ClientMessage encoded = CacheIterateEntriesCodec.encodeRequest(aString, aListOfIntegerToInteger, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeResponse() { + int fileClientMessageIndex = 600; + 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 = 601; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeResponse() { + int fileClientMessageIndex = 602; + 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 = 603; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_handleCacheBatchInvalidationEvent() { + int fileClientMessageIndex = 604; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CacheAddNearCacheInvalidationListenerCodecHandler handler = new CacheAddNearCacheInvalidationListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 605; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeRequest(aListOfStrings, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 606; + 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 = 607; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeResponse() { + int fileClientMessageIndex = 608; + 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 = 609; + 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 = 610; + 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 = 611; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeRequest(aString, aListOfData, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeResponse() { + int fileClientMessageIndex = 612; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CacheSetExpiryPolicyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeRequest() { + int fileClientMessageIndex = 613; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeRequest(anXid); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeResponse() { + int fileClientMessageIndex = 614; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeRequest() { + int fileClientMessageIndex = 615; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfXids, XATransactionCollectTransactionsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionFinalizeCodec_encodeRequest() { + int fileClientMessageIndex = 617; + ClientMessage encoded = XATransactionFinalizeCodec.encodeRequest(anXid, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeResponse() { + int fileClientMessageIndex = 618; + } + + @Test + public void test_XATransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 619; + ClientMessage encoded = XATransactionCommitCodec.encodeRequest(aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 620; + } + + @Test + public void test_XATransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 621; + ClientMessage encoded = XATransactionCreateCodec.encodeRequest(anXid, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 622; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage encoded = XATransactionPrepareCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeResponse() { + int fileClientMessageIndex = 624; + } + + @Test + public void test_XATransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 625; + ClientMessage encoded = XATransactionRollbackCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 626; + } + + @Test + public void test_TransactionCommitCodec_encodeRequest() { + int fileClientMessageIndex = 627; + ClientMessage encoded = TransactionCommitCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeResponse() { + int fileClientMessageIndex = 628; + } + + @Test + public void test_TransactionCreateCodec_encodeRequest() { + int fileClientMessageIndex = 629; + ClientMessage encoded = TransactionCreateCodec.encodeRequest(aLong, anInt, anInt, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeResponse() { + int fileClientMessageIndex = 630; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, TransactionCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_TransactionRollbackCodec_encodeRequest() { + int fileClientMessageIndex = 631; + ClientMessage encoded = TransactionRollbackCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeResponse() { + int fileClientMessageIndex = 632; + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeRequest() { + int fileClientMessageIndex = 633; + 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 = 634; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfDataToData, ContinuousQueryPublisherCreateWithValueCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_encodeRequest() { + int fileClientMessageIndex = 635; + 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 = 636; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfData, ContinuousQueryPublisherCreateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_encodeRequest() { + int fileClientMessageIndex = 637; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeResponse() { + int fileClientMessageIndex = 638; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryMadePublishableCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeRequest() { + int fileClientMessageIndex = 639; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeRequest(aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeResponse() { + int fileClientMessageIndex = 640; + 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 = 641; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_handleQueryCacheBatchEvent() { + int fileClientMessageIndex = 642; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ContinuousQueryAddListenerCodecHandler handler = new ContinuousQueryAddListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_encodeRequest() { + int fileClientMessageIndex = 643; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeRequest(aString, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeResponse() { + int fileClientMessageIndex = 644; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQuerySetReadCursorCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_encodeRequest() { + int fileClientMessageIndex = 645; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeResponse() { + int fileClientMessageIndex = 646; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ContinuousQueryDestroyCacheCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage encoded = RingbufferSizeCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferSizeCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferTailSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeRequest() { + int fileClientMessageIndex = 651; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeResponse() { + int fileClientMessageIndex = 652; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferHeadSequenceCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage encoded = RingbufferCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferRemainingCapacityCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddCodec_encodeRequest() { + int fileClientMessageIndex = 657; + ClientMessage encoded = RingbufferAddCodec.encodeRequest(aString, anInt, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeResponse() { + int fileClientMessageIndex = 658; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadOneCodec_encodeRequest() { + int fileClientMessageIndex = 659; + ClientMessage encoded = RingbufferReadOneCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeResponse() { + int fileClientMessageIndex = 660; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, RingbufferReadOneCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferAddAllCodec_encodeRequest() { + int fileClientMessageIndex = 661; + ClientMessage encoded = RingbufferAddAllCodec.encodeRequest(aString, aListOfData, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeResponse() { + int fileClientMessageIndex = 662; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, RingbufferAddAllCodec.decodeResponse(fromFile))); + } + + @Test + public void test_RingbufferReadManyCodec_encodeRequest() { + int fileClientMessageIndex = 663; + 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 = 664; + 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 = 665; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 666; + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, DurableExecutorIsShutdownCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 669; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeRequest(aString, aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 670; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, DurableExecutorSubmitToPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_encodeRequest() { + int fileClientMessageIndex = 671; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeResponse() { + int fileClientMessageIndex = 672; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, DurableExecutorRetrieveResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 673; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 674; + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeRequest() { + int fileClientMessageIndex = 675; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeResponse() { + int fileClientMessageIndex = 676; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, DurableExecutorRetrieveAndDisposeResultCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CardinalityEstimatorAddCodec_encodeRequest() { + int fileClientMessageIndex = 677; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeRequest(aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeResponse() { + int fileClientMessageIndex = 678; + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CardinalityEstimatorEstimateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_encodeRequest() { + int fileClientMessageIndex = 681; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeRequest(aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeResponse() { + int fileClientMessageIndex = 682; + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 683; + 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 = 684; + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_encodeRequest() { + int fileClientMessageIndex = 685; + 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 = 686; + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeResponse() { + int fileClientMessageIndex = 688; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfScheduledTaskHandler, ScheduledExecutorGetAllScheduledFuturesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 689; + ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 690; + 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 = 691; + ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 692; + 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 = 693; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 694; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 695; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 696; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, ScheduledExecutorGetDelayFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 697; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeRequest(aString, aString, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 698; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 699; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeRequest(aString, aString, aUUID, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 700; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorCancelFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 701; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 702; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 703; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 704; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsCancelledFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 705; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 706; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 707; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 708; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, ScheduledExecutorIsDoneFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 709; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 710; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ScheduledExecutorGetResultFromPartitionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 711; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 712; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aData, ScheduledExecutorGetResultFromMemberCodec.decodeResponse(fromFile))); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeRequest() { + int fileClientMessageIndex = 713; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeResponse() { + int fileClientMessageIndex = 714; + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_encodeRequest() { + int fileClientMessageIndex = 715; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeRequest(aString, aString, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeResponse() { + int fileClientMessageIndex = 716; + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 717; + 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 = 718; + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_encodeRequest() { + int fileClientMessageIndex = 719; + 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 = 720; + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 721; + 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 = 722; + } + + @Test + public void test_DynamicConfigAddListConfigCodec_encodeRequest() { + int fileClientMessageIndex = 723; + 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 = 724; + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_encodeRequest() { + int fileClientMessageIndex = 725; + 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 = 726; + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 727; + 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 = 728; + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 729; + 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 = 730; + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 731; + 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 = 732; + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 733; + 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 = 734; + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 735; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeRequest(aString, anInt, anInt, anInt, aString, aString, anInt, aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeResponse() { + int fileClientMessageIndex = 736; + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_encodeRequest() { + int fileClientMessageIndex = 737; + 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 = 738; + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 739; + 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); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 740; + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_encodeRequest() { + int fileClientMessageIndex = 741; + 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 = 742; + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeRequest() { + int fileClientMessageIndex = 743; + 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); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeResponse() { + int fileClientMessageIndex = 744; + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeRequest() { + int fileClientMessageIndex = 745; + 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 = 746; + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_encodeRequest() { + int fileClientMessageIndex = 747; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeRequest(aString, anInt, aBoolean, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeResponse() { + int fileClientMessageIndex = 748; + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_encodeRequest() { + int fileClientMessageIndex = 749; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeRequest(aString, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeResponse() { + int fileClientMessageIndex = 750; + 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 = 751; + ClientMessage encoded = PNCounterGetCodec.encodeRequest(aString, aListOfUuidToLong, aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeResponse() { + int fileClientMessageIndex = 752; + 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 = 753; + 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 = 754; + 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 = 755; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeResponse() { + int fileClientMessageIndex = 756; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, PNCounterGetConfiguredReplicaCountCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeResponse() { + int fileClientMessageIndex = 758; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPGroupCreateCPGroupCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_encodeRequest() { + int fileClientMessageIndex = 759; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeRequest(aRaftGroupId, aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeResponse() { + int fileClientMessageIndex = 760; + } + + @Test + public void test_CPSessionCreateSessionCodec_encodeRequest() { + int fileClientMessageIndex = 761; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeRequest(aRaftGroupId, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeResponse() { + int fileClientMessageIndex = 762; + 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 = 763; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeResponse() { + int fileClientMessageIndex = 764; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSessionCloseSessionCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_encodeRequest() { + int fileClientMessageIndex = 765; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeRequest(aRaftGroupId, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeResponse() { + int fileClientMessageIndex = 766; + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeRequest(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aLong, CPSessionGenerateThreadIdCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCReadMetricsCodec_encodeRequest() { + int fileClientMessageIndex = 769; + ClientMessage encoded = MCReadMetricsCodec.encodeRequest(aUUID, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeResponse() { + int fileClientMessageIndex = 770; + 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 = 771; + ClientMessage encoded = MCChangeClusterStateCodec.encodeRequest(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeResponse() { + int fileClientMessageIndex = 772; + } + + @Test + public void test_MCGetMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage encoded = MCGetMapConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeResponse() { + int fileClientMessageIndex = 774; + 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)); + } + + @Test + public void test_MCUpdateMapConfigCodec_encodeRequest() { + int fileClientMessageIndex = 775; + 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 = 776; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeRequest() { + int fileClientMessageIndex = 777; + ClientMessage encoded = MCGetMemberConfigCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeResponse() { + int fileClientMessageIndex = 778; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMemberConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunGcCodec_encodeRequest() { + int fileClientMessageIndex = 779; + ClientMessage encoded = MCRunGcCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeResponse() { + int fileClientMessageIndex = 780; + } + + @Test + public void test_MCGetThreadDumpCodec_encodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage encoded = MCGetThreadDumpCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetThreadDumpCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCShutdownMemberCodec_encodeRequest() { + int fileClientMessageIndex = 783; + ClientMessage encoded = MCShutdownMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeResponse() { + int fileClientMessageIndex = 784; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeRequest() { + int fileClientMessageIndex = 785; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeResponse() { + int fileClientMessageIndex = 786; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeRequest() { + int fileClientMessageIndex = 787; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeResponse() { + int fileClientMessageIndex = 788; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfStringToString, MCGetSystemPropertiesCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeRequest() { + int fileClientMessageIndex = 789; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetTimedMemberStateCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 791; + ClientMessage encoded = MCMatchMCConfigCodec.encodeRequest(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 792; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCMatchMCConfigCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCApplyMCConfigCodec_encodeRequest() { + int fileClientMessageIndex = 793; + ClientMessage encoded = MCApplyMCConfigCodec.encodeRequest(aString, anInt, aListOfClientBwListEntries); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeResponse() { + int fileClientMessageIndex = 794; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeRequest() { + int fileClientMessageIndex = 795; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeResponse() { + int fileClientMessageIndex = 796; + 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)); + } + + @Test + public void test_MCShutdownClusterCodec_encodeRequest() { + int fileClientMessageIndex = 797; + ClientMessage encoded = MCShutdownClusterCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeResponse() { + int fileClientMessageIndex = 798; + } + + @Test + public void test_MCChangeClusterVersionCodec_encodeRequest() { + int fileClientMessageIndex = 799; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeRequest(aByte, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeResponse() { + int fileClientMessageIndex = 800; + } + + @Test + public void test_MCRunScriptCodec_encodeRequest() { + int fileClientMessageIndex = 801; + ClientMessage encoded = MCRunScriptCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeResponse() { + int fileClientMessageIndex = 802; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCRunScriptCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCRunConsoleCommandCodec_encodeRequest() { + int fileClientMessageIndex = 803; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeResponse() { + int fileClientMessageIndex = 804; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCRunConsoleCommandCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_encodeRequest() { + int fileClientMessageIndex = 805; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeRequest(aString, aString, aByte); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeResponse() { + int fileClientMessageIndex = 806; + } + + @Test + public void test_MCClearWanQueuesCodec_encodeRequest() { + int fileClientMessageIndex = 807; + ClientMessage encoded = MCClearWanQueuesCodec.encodeRequest(aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeResponse() { + int fileClientMessageIndex = 808; + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_encodeRequest() { + int fileClientMessageIndex = 809; + 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 = 810; + 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 = 811; + ClientMessage encoded = MCWanSyncMapCodec.encodeRequest(aString, aString, anInt, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeResponse() { + int fileClientMessageIndex = 812; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCWanSyncMapCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCCheckWanConsistencyCodec_encodeRequest() { + int fileClientMessageIndex = 813; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeRequest(aString, aString, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeResponse() { + int fileClientMessageIndex = 814; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCCheckWanConsistencyCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPollMCEventsCodec_encodeRequest() { + int fileClientMessageIndex = 815; + ClientMessage encoded = MCPollMCEventsCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfMCEvents, MCPollMCEventsCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCGetCPMembersCodec_encodeRequest() { + int fileClientMessageIndex = 817; + ClientMessage encoded = MCGetCPMembersCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeResponse() { + int fileClientMessageIndex = 818; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aListOfUUIDToUUID, MCGetCPMembersCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 819; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 820; + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeResponse() { + int fileClientMessageIndex = 822; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeRequest() { + int fileClientMessageIndex = 823; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeResponse() { + int fileClientMessageIndex = 824; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeRequest() { + int fileClientMessageIndex = 825; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerPartialStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerForceStartCodec_encodeRequest() { + int fileClientMessageIndex = 827; + ClientMessage encoded = MCTriggerForceStartCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCTriggerForceStartCodec.decodeResponse(fromFile))); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 829; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 830; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeRequest() { + int fileClientMessageIndex = 831; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeRequest(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeResponse() { + int fileClientMessageIndex = 832; + } + + @Test + public void test_SqlExecuteCodec_encodeRequest() { + int fileClientMessageIndex = 833; + ClientMessage encoded = SqlExecuteCodec.encodeRequest(aString, aListOfData, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeResponse() { + int fileClientMessageIndex = 834; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlExecuteCodec.ResponseParameters parameters = SqlExecuteCodec.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_SqlFetchCodec_encodeRequest() { + int fileClientMessageIndex = 835; + ClientMessage encoded = SqlFetchCodec.encodeRequest(anSqlQueryId, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeResponse() { + int fileClientMessageIndex = 836; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + SqlFetchCodec.ResponseParameters parameters = SqlFetchCodec.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 = 837; + ClientMessage encoded = SqlCloseCodec.encodeRequest(anSqlQueryId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeResponse() { + int fileClientMessageIndex = 838; + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 839; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 840; + 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 = 841; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddMembershipListenerCodecHandler handler = new CPSubsystemAddMembershipListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeRequest() { + int fileClientMessageIndex = 842; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeResponse() { + int fileClientMessageIndex = 843; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveMembershipListenerCodec.decodeResponse(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 844; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeRequest(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 845; + 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 = 846; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + CPSubsystemAddGroupAvailabilityListenerCodecHandler handler = new CPSubsystemAddGroupAvailabilityListenerCodecHandler(); + handler.handle(fromFile); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeRequest() { + int fileClientMessageIndex = 847; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeRequest(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemRemoveGroupAvailabilityListenerCodec.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_1.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_1.java index dde9a3f2ec678..de522341a9b76 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_1.java +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_1.java @@ -358,55 +358,9 @@ public void test_ClientTriggerPartitionAssignmentCodec_encodeResponse() { 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_MapPutCodec_decodeRequest() { - int fileClientMessageIndex = 43; + int fileClientMessageIndex = 37; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutCodec.RequestParameters parameters = MapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -418,7 +372,7 @@ public void test_MapPutCodec_decodeRequest() { @Test public void test_MapPutCodec_encodeResponse() { - int fileClientMessageIndex = 44; + int fileClientMessageIndex = 38; ClientMessage encoded = MapPutCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -426,7 +380,7 @@ public void test_MapPutCodec_encodeResponse() { @Test public void test_MapGetCodec_decodeRequest() { - int fileClientMessageIndex = 45; + int fileClientMessageIndex = 39; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetCodec.RequestParameters parameters = MapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -436,7 +390,7 @@ public void test_MapGetCodec_decodeRequest() { @Test public void test_MapGetCodec_encodeResponse() { - int fileClientMessageIndex = 46; + int fileClientMessageIndex = 40; ClientMessage encoded = MapGetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -444,7 +398,7 @@ public void test_MapGetCodec_encodeResponse() { @Test public void test_MapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 47; + int fileClientMessageIndex = 41; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveCodec.RequestParameters parameters = MapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -454,7 +408,7 @@ public void test_MapRemoveCodec_decodeRequest() { @Test public void test_MapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 48; + int fileClientMessageIndex = 42; ClientMessage encoded = MapRemoveCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -462,7 +416,7 @@ public void test_MapRemoveCodec_encodeResponse() { @Test public void test_MapReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 49; + int fileClientMessageIndex = 43; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapReplaceCodec.RequestParameters parameters = MapReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -473,7 +427,7 @@ public void test_MapReplaceCodec_decodeRequest() { @Test public void test_MapReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 50; + int fileClientMessageIndex = 44; ClientMessage encoded = MapReplaceCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -481,7 +435,7 @@ public void test_MapReplaceCodec_encodeResponse() { @Test public void test_MapReplaceIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 51; + int fileClientMessageIndex = 45; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapReplaceIfSameCodec.RequestParameters parameters = MapReplaceIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -493,7 +447,7 @@ public void test_MapReplaceIfSameCodec_decodeRequest() { @Test public void test_MapReplaceIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 52; + int fileClientMessageIndex = 46; ClientMessage encoded = MapReplaceIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -501,7 +455,7 @@ public void test_MapReplaceIfSameCodec_encodeResponse() { @Test public void test_MapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 53; + int fileClientMessageIndex = 47; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapContainsKeyCodec.RequestParameters parameters = MapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -511,7 +465,7 @@ public void test_MapContainsKeyCodec_decodeRequest() { @Test public void test_MapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 54; + int fileClientMessageIndex = 48; ClientMessage encoded = MapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -519,7 +473,7 @@ public void test_MapContainsKeyCodec_encodeResponse() { @Test public void test_MapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 55; + int fileClientMessageIndex = 49; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapContainsValueCodec.RequestParameters parameters = MapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -528,7 +482,7 @@ public void test_MapContainsValueCodec_decodeRequest() { @Test public void test_MapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 56; + int fileClientMessageIndex = 50; ClientMessage encoded = MapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -536,7 +490,7 @@ public void test_MapContainsValueCodec_encodeResponse() { @Test public void test_MapRemoveIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 57; + int fileClientMessageIndex = 51; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveIfSameCodec.RequestParameters parameters = MapRemoveIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -547,7 +501,7 @@ public void test_MapRemoveIfSameCodec_decodeRequest() { @Test public void test_MapRemoveIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 58; + int fileClientMessageIndex = 52; ClientMessage encoded = MapRemoveIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -555,7 +509,7 @@ public void test_MapRemoveIfSameCodec_encodeResponse() { @Test public void test_MapDeleteCodec_decodeRequest() { - int fileClientMessageIndex = 59; + int fileClientMessageIndex = 53; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapDeleteCodec.RequestParameters parameters = MapDeleteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -565,7 +519,7 @@ public void test_MapDeleteCodec_decodeRequest() { @Test public void test_MapDeleteCodec_encodeResponse() { - int fileClientMessageIndex = 60; + int fileClientMessageIndex = 54; ClientMessage encoded = MapDeleteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -573,14 +527,14 @@ public void test_MapDeleteCodec_encodeResponse() { @Test public void test_MapFlushCodec_decodeRequest() { - int fileClientMessageIndex = 61; + int fileClientMessageIndex = 55; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapFlushCodec.decodeRequest(fromFile))); } @Test public void test_MapFlushCodec_encodeResponse() { - int fileClientMessageIndex = 62; + int fileClientMessageIndex = 56; ClientMessage encoded = MapFlushCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -588,7 +542,7 @@ public void test_MapFlushCodec_encodeResponse() { @Test public void test_MapTryRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 63; + int fileClientMessageIndex = 57; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapTryRemoveCodec.RequestParameters parameters = MapTryRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -599,7 +553,7 @@ public void test_MapTryRemoveCodec_decodeRequest() { @Test public void test_MapTryRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 64; + int fileClientMessageIndex = 58; ClientMessage encoded = MapTryRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -607,7 +561,7 @@ public void test_MapTryRemoveCodec_encodeResponse() { @Test public void test_MapTryPutCodec_decodeRequest() { - int fileClientMessageIndex = 65; + int fileClientMessageIndex = 59; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapTryPutCodec.RequestParameters parameters = MapTryPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -619,7 +573,7 @@ public void test_MapTryPutCodec_decodeRequest() { @Test public void test_MapTryPutCodec_encodeResponse() { - int fileClientMessageIndex = 66; + int fileClientMessageIndex = 60; ClientMessage encoded = MapTryPutCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -627,7 +581,7 @@ public void test_MapTryPutCodec_encodeResponse() { @Test public void test_MapPutTransientCodec_decodeRequest() { - int fileClientMessageIndex = 67; + int fileClientMessageIndex = 61; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutTransientCodec.RequestParameters parameters = MapPutTransientCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -639,7 +593,7 @@ public void test_MapPutTransientCodec_decodeRequest() { @Test public void test_MapPutTransientCodec_encodeResponse() { - int fileClientMessageIndex = 68; + int fileClientMessageIndex = 62; ClientMessage encoded = MapPutTransientCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -647,7 +601,7 @@ public void test_MapPutTransientCodec_encodeResponse() { @Test public void test_MapPutIfAbsentCodec_decodeRequest() { - int fileClientMessageIndex = 69; + int fileClientMessageIndex = 63; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutIfAbsentCodec.RequestParameters parameters = MapPutIfAbsentCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -659,7 +613,7 @@ public void test_MapPutIfAbsentCodec_decodeRequest() { @Test public void test_MapPutIfAbsentCodec_encodeResponse() { - int fileClientMessageIndex = 70; + int fileClientMessageIndex = 64; ClientMessage encoded = MapPutIfAbsentCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -667,7 +621,7 @@ public void test_MapPutIfAbsentCodec_encodeResponse() { @Test public void test_MapSetCodec_decodeRequest() { - int fileClientMessageIndex = 71; + int fileClientMessageIndex = 65; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSetCodec.RequestParameters parameters = MapSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -679,7 +633,7 @@ public void test_MapSetCodec_decodeRequest() { @Test public void test_MapSetCodec_encodeResponse() { - int fileClientMessageIndex = 72; + int fileClientMessageIndex = 66; ClientMessage encoded = MapSetCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -687,7 +641,7 @@ public void test_MapSetCodec_encodeResponse() { @Test public void test_MapLockCodec_decodeRequest() { - int fileClientMessageIndex = 73; + int fileClientMessageIndex = 67; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapLockCodec.RequestParameters parameters = MapLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -699,7 +653,7 @@ public void test_MapLockCodec_decodeRequest() { @Test public void test_MapLockCodec_encodeResponse() { - int fileClientMessageIndex = 74; + int fileClientMessageIndex = 68; ClientMessage encoded = MapLockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -707,7 +661,7 @@ public void test_MapLockCodec_encodeResponse() { @Test public void test_MapTryLockCodec_decodeRequest() { - int fileClientMessageIndex = 75; + int fileClientMessageIndex = 69; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapTryLockCodec.RequestParameters parameters = MapTryLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -720,7 +674,7 @@ public void test_MapTryLockCodec_decodeRequest() { @Test public void test_MapTryLockCodec_encodeResponse() { - int fileClientMessageIndex = 76; + int fileClientMessageIndex = 70; ClientMessage encoded = MapTryLockCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -728,7 +682,7 @@ public void test_MapTryLockCodec_encodeResponse() { @Test public void test_MapIsLockedCodec_decodeRequest() { - int fileClientMessageIndex = 77; + int fileClientMessageIndex = 71; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapIsLockedCodec.RequestParameters parameters = MapIsLockedCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -737,7 +691,7 @@ public void test_MapIsLockedCodec_decodeRequest() { @Test public void test_MapIsLockedCodec_encodeResponse() { - int fileClientMessageIndex = 78; + int fileClientMessageIndex = 72; ClientMessage encoded = MapIsLockedCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -745,7 +699,7 @@ public void test_MapIsLockedCodec_encodeResponse() { @Test public void test_MapUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 79; + int fileClientMessageIndex = 73; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapUnlockCodec.RequestParameters parameters = MapUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -756,7 +710,7 @@ public void test_MapUnlockCodec_decodeRequest() { @Test public void test_MapUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 80; + int fileClientMessageIndex = 74; ClientMessage encoded = MapUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -764,7 +718,7 @@ public void test_MapUnlockCodec_encodeResponse() { @Test public void test_MapAddInterceptorCodec_decodeRequest() { - int fileClientMessageIndex = 81; + int fileClientMessageIndex = 75; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddInterceptorCodec.RequestParameters parameters = MapAddInterceptorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -773,7 +727,7 @@ public void test_MapAddInterceptorCodec_decodeRequest() { @Test public void test_MapAddInterceptorCodec_encodeResponse() { - int fileClientMessageIndex = 82; + int fileClientMessageIndex = 76; ClientMessage encoded = MapAddInterceptorCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -781,7 +735,7 @@ public void test_MapAddInterceptorCodec_encodeResponse() { @Test public void test_MapRemoveInterceptorCodec_decodeRequest() { - int fileClientMessageIndex = 83; + int fileClientMessageIndex = 77; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveInterceptorCodec.RequestParameters parameters = MapRemoveInterceptorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -790,7 +744,7 @@ public void test_MapRemoveInterceptorCodec_decodeRequest() { @Test public void test_MapRemoveInterceptorCodec_encodeResponse() { - int fileClientMessageIndex = 84; + int fileClientMessageIndex = 78; ClientMessage encoded = MapRemoveInterceptorCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -798,7 +752,7 @@ public void test_MapRemoveInterceptorCodec_encodeResponse() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 85; + int fileClientMessageIndex = 79; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -811,7 +765,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 86; + int fileClientMessageIndex = 80; ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -819,7 +773,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 87; + int fileClientMessageIndex = 81; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -827,7 +781,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { @Test public void test_MapAddEntryListenerWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 88; + int fileClientMessageIndex = 82; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -839,7 +793,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_decodeRequest() { @Test public void test_MapAddEntryListenerWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 89; + int fileClientMessageIndex = 83; ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -847,7 +801,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_encodeResponse() { @Test public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 90; + int fileClientMessageIndex = 84; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -855,7 +809,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { @Test public void test_MapAddEntryListenerToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 91; + int fileClientMessageIndex = 85; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyCodec.RequestParameters parameters = MapAddEntryListenerToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -867,7 +821,7 @@ public void test_MapAddEntryListenerToKeyCodec_decodeRequest() { @Test public void test_MapAddEntryListenerToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 92; + int fileClientMessageIndex = 86; ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -875,7 +829,7 @@ public void test_MapAddEntryListenerToKeyCodec_encodeResponse() { @Test public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { - int fileClientMessageIndex = 93; + int fileClientMessageIndex = 87; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -883,7 +837,7 @@ public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { @Test public void test_MapAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 94; + int fileClientMessageIndex = 88; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerCodec.RequestParameters parameters = MapAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -894,7 +848,7 @@ public void test_MapAddEntryListenerCodec_decodeRequest() { @Test public void test_MapAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 95; + int fileClientMessageIndex = 89; ClientMessage encoded = MapAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -902,7 +856,7 @@ public void test_MapAddEntryListenerCodec_encodeResponse() { @Test public void test_MapAddEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 96; + int fileClientMessageIndex = 90; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -910,7 +864,7 @@ public void test_MapAddEntryListenerCodec_encodeEntryEvent() { @Test public void test_MapRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 97; + int fileClientMessageIndex = 91; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveEntryListenerCodec.RequestParameters parameters = MapRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -919,7 +873,7 @@ public void test_MapRemoveEntryListenerCodec_decodeRequest() { @Test public void test_MapRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 98; + int fileClientMessageIndex = 92; ClientMessage encoded = MapRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -927,7 +881,7 @@ public void test_MapRemoveEntryListenerCodec_encodeResponse() { @Test public void test_MapAddPartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 99; + int fileClientMessageIndex = 93; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddPartitionLostListenerCodec.RequestParameters parameters = MapAddPartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -936,7 +890,7 @@ public void test_MapAddPartitionLostListenerCodec_decodeRequest() { @Test public void test_MapAddPartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 100; + int fileClientMessageIndex = 94; ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -944,7 +898,7 @@ public void test_MapAddPartitionLostListenerCodec_encodeResponse() { @Test public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() { - int fileClientMessageIndex = 101; + int fileClientMessageIndex = 95; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeMapPartitionLostEvent(anInt, aUUID); compareClientMessages(fromFile, encoded); @@ -952,7 +906,7 @@ public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() @Test public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 102; + int fileClientMessageIndex = 96; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemovePartitionLostListenerCodec.RequestParameters parameters = MapRemovePartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -961,7 +915,7 @@ public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { @Test public void test_MapRemovePartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 103; + int fileClientMessageIndex = 97; ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -969,7 +923,7 @@ public void test_MapRemovePartitionLostListenerCodec_encodeResponse() { @Test public void test_MapGetEntryViewCodec_decodeRequest() { - int fileClientMessageIndex = 104; + int fileClientMessageIndex = 98; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetEntryViewCodec.RequestParameters parameters = MapGetEntryViewCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -979,7 +933,7 @@ public void test_MapGetEntryViewCodec_decodeRequest() { @Test public void test_MapGetEntryViewCodec_encodeResponse() { - int fileClientMessageIndex = 105; + int fileClientMessageIndex = 99; ClientMessage encoded = MapGetEntryViewCodec.encodeResponse(null, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -987,7 +941,7 @@ public void test_MapGetEntryViewCodec_encodeResponse() { @Test public void test_MapEvictCodec_decodeRequest() { - int fileClientMessageIndex = 106; + int fileClientMessageIndex = 100; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEvictCodec.RequestParameters parameters = MapEvictCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -997,7 +951,7 @@ public void test_MapEvictCodec_decodeRequest() { @Test public void test_MapEvictCodec_encodeResponse() { - int fileClientMessageIndex = 107; + int fileClientMessageIndex = 101; ClientMessage encoded = MapEvictCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1005,14 +959,14 @@ public void test_MapEvictCodec_encodeResponse() { @Test public void test_MapEvictAllCodec_decodeRequest() { - int fileClientMessageIndex = 108; + int fileClientMessageIndex = 102; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapEvictAllCodec.decodeRequest(fromFile))); } @Test public void test_MapEvictAllCodec_encodeResponse() { - int fileClientMessageIndex = 109; + int fileClientMessageIndex = 103; ClientMessage encoded = MapEvictAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1020,7 +974,7 @@ public void test_MapEvictAllCodec_encodeResponse() { @Test public void test_MapLoadAllCodec_decodeRequest() { - int fileClientMessageIndex = 110; + int fileClientMessageIndex = 104; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapLoadAllCodec.RequestParameters parameters = MapLoadAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1029,7 +983,7 @@ public void test_MapLoadAllCodec_decodeRequest() { @Test public void test_MapLoadAllCodec_encodeResponse() { - int fileClientMessageIndex = 111; + int fileClientMessageIndex = 105; ClientMessage encoded = MapLoadAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1037,7 +991,7 @@ public void test_MapLoadAllCodec_encodeResponse() { @Test public void test_MapLoadGivenKeysCodec_decodeRequest() { - int fileClientMessageIndex = 112; + int fileClientMessageIndex = 106; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapLoadGivenKeysCodec.RequestParameters parameters = MapLoadGivenKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1047,7 +1001,7 @@ public void test_MapLoadGivenKeysCodec_decodeRequest() { @Test public void test_MapLoadGivenKeysCodec_encodeResponse() { - int fileClientMessageIndex = 113; + int fileClientMessageIndex = 107; ClientMessage encoded = MapLoadGivenKeysCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1055,14 +1009,14 @@ public void test_MapLoadGivenKeysCodec_encodeResponse() { @Test public void test_MapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 114; + int fileClientMessageIndex = 108; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapKeySetCodec.decodeRequest(fromFile))); } @Test public void test_MapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 115; + int fileClientMessageIndex = 109; ClientMessage encoded = MapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1070,7 +1024,7 @@ public void test_MapKeySetCodec_encodeResponse() { @Test public void test_MapGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 116; + int fileClientMessageIndex = 110; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetAllCodec.RequestParameters parameters = MapGetAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1079,7 +1033,7 @@ public void test_MapGetAllCodec_decodeRequest() { @Test public void test_MapGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 117; + int fileClientMessageIndex = 111; ClientMessage encoded = MapGetAllCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1087,14 +1041,14 @@ public void test_MapGetAllCodec_encodeResponse() { @Test public void test_MapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 118; + int fileClientMessageIndex = 112; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapValuesCodec.decodeRequest(fromFile))); } @Test public void test_MapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 119; + int fileClientMessageIndex = 113; ClientMessage encoded = MapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1102,14 +1056,14 @@ public void test_MapValuesCodec_encodeResponse() { @Test public void test_MapEntrySetCodec_decodeRequest() { - int fileClientMessageIndex = 120; + int fileClientMessageIndex = 114; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapEntrySetCodec.decodeRequest(fromFile))); } @Test public void test_MapEntrySetCodec_encodeResponse() { - int fileClientMessageIndex = 121; + int fileClientMessageIndex = 115; ClientMessage encoded = MapEntrySetCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1117,7 +1071,7 @@ public void test_MapEntrySetCodec_encodeResponse() { @Test public void test_MapKeySetWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 122; + int fileClientMessageIndex = 116; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapKeySetWithPredicateCodec.RequestParameters parameters = MapKeySetWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1126,7 +1080,7 @@ public void test_MapKeySetWithPredicateCodec_decodeRequest() { @Test public void test_MapKeySetWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 123; + int fileClientMessageIndex = 117; ClientMessage encoded = MapKeySetWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1134,7 +1088,7 @@ public void test_MapKeySetWithPredicateCodec_encodeResponse() { @Test public void test_MapValuesWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 124; + int fileClientMessageIndex = 118; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapValuesWithPredicateCodec.RequestParameters parameters = MapValuesWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1143,7 +1097,7 @@ public void test_MapValuesWithPredicateCodec_decodeRequest() { @Test public void test_MapValuesWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 125; + int fileClientMessageIndex = 119; ClientMessage encoded = MapValuesWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1151,7 +1105,7 @@ public void test_MapValuesWithPredicateCodec_encodeResponse() { @Test public void test_MapEntriesWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 126; + int fileClientMessageIndex = 120; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEntriesWithPredicateCodec.RequestParameters parameters = MapEntriesWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1160,7 +1114,7 @@ public void test_MapEntriesWithPredicateCodec_decodeRequest() { @Test public void test_MapEntriesWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 127; + int fileClientMessageIndex = 121; ClientMessage encoded = MapEntriesWithPredicateCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1168,7 +1122,7 @@ public void test_MapEntriesWithPredicateCodec_encodeResponse() { @Test public void test_MapAddIndexCodec_decodeRequest() { - int fileClientMessageIndex = 128; + int fileClientMessageIndex = 122; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddIndexCodec.RequestParameters parameters = MapAddIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1177,7 +1131,7 @@ public void test_MapAddIndexCodec_decodeRequest() { @Test public void test_MapAddIndexCodec_encodeResponse() { - int fileClientMessageIndex = 129; + int fileClientMessageIndex = 123; ClientMessage encoded = MapAddIndexCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1185,14 +1139,14 @@ public void test_MapAddIndexCodec_encodeResponse() { @Test public void test_MapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 130; + int fileClientMessageIndex = 124; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapSizeCodec.decodeRequest(fromFile))); } @Test public void test_MapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 131; + int fileClientMessageIndex = 125; ClientMessage encoded = MapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1200,14 +1154,14 @@ public void test_MapSizeCodec_encodeResponse() { @Test public void test_MapIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 132; + int fileClientMessageIndex = 126; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_MapIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 133; + int fileClientMessageIndex = 127; ClientMessage encoded = MapIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1215,7 +1169,7 @@ public void test_MapIsEmptyCodec_encodeResponse() { @Test public void test_MapPutAllCodec_decodeRequest() { - int fileClientMessageIndex = 134; + int fileClientMessageIndex = 128; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutAllCodec.RequestParameters parameters = MapPutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1226,7 +1180,7 @@ public void test_MapPutAllCodec_decodeRequest() { @Test public void test_MapPutAllCodec_encodeResponse() { - int fileClientMessageIndex = 135; + int fileClientMessageIndex = 129; ClientMessage encoded = MapPutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1234,14 +1188,14 @@ public void test_MapPutAllCodec_encodeResponse() { @Test public void test_MapClearCodec_decodeRequest() { - int fileClientMessageIndex = 136; + int fileClientMessageIndex = 130; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapClearCodec.decodeRequest(fromFile))); } @Test public void test_MapClearCodec_encodeResponse() { - int fileClientMessageIndex = 137; + int fileClientMessageIndex = 131; ClientMessage encoded = MapClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1249,7 +1203,7 @@ public void test_MapClearCodec_encodeResponse() { @Test public void test_MapExecuteOnKeyCodec_decodeRequest() { - int fileClientMessageIndex = 138; + int fileClientMessageIndex = 132; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteOnKeyCodec.RequestParameters parameters = MapExecuteOnKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1260,7 +1214,7 @@ public void test_MapExecuteOnKeyCodec_decodeRequest() { @Test public void test_MapExecuteOnKeyCodec_encodeResponse() { - int fileClientMessageIndex = 139; + int fileClientMessageIndex = 133; ClientMessage encoded = MapExecuteOnKeyCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1268,7 +1222,7 @@ public void test_MapExecuteOnKeyCodec_encodeResponse() { @Test public void test_MapSubmitToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 140; + int fileClientMessageIndex = 134; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSubmitToKeyCodec.RequestParameters parameters = MapSubmitToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1279,7 +1233,7 @@ public void test_MapSubmitToKeyCodec_decodeRequest() { @Test public void test_MapSubmitToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 141; + int fileClientMessageIndex = 135; ClientMessage encoded = MapSubmitToKeyCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1287,7 +1241,7 @@ public void test_MapSubmitToKeyCodec_encodeResponse() { @Test public void test_MapExecuteOnAllKeysCodec_decodeRequest() { - int fileClientMessageIndex = 142; + int fileClientMessageIndex = 136; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteOnAllKeysCodec.RequestParameters parameters = MapExecuteOnAllKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1296,7 +1250,7 @@ public void test_MapExecuteOnAllKeysCodec_decodeRequest() { @Test public void test_MapExecuteOnAllKeysCodec_encodeResponse() { - int fileClientMessageIndex = 143; + int fileClientMessageIndex = 137; ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1304,7 +1258,7 @@ public void test_MapExecuteOnAllKeysCodec_encodeResponse() { @Test public void test_MapExecuteWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 144; + int fileClientMessageIndex = 138; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteWithPredicateCodec.RequestParameters parameters = MapExecuteWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1314,7 +1268,7 @@ public void test_MapExecuteWithPredicateCodec_decodeRequest() { @Test public void test_MapExecuteWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 145; + int fileClientMessageIndex = 139; ClientMessage encoded = MapExecuteWithPredicateCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1322,7 +1276,7 @@ public void test_MapExecuteWithPredicateCodec_encodeResponse() { @Test public void test_MapExecuteOnKeysCodec_decodeRequest() { - int fileClientMessageIndex = 146; + int fileClientMessageIndex = 140; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteOnKeysCodec.RequestParameters parameters = MapExecuteOnKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1332,7 +1286,7 @@ public void test_MapExecuteOnKeysCodec_decodeRequest() { @Test public void test_MapExecuteOnKeysCodec_encodeResponse() { - int fileClientMessageIndex = 147; + int fileClientMessageIndex = 141; ClientMessage encoded = MapExecuteOnKeysCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1340,7 +1294,7 @@ public void test_MapExecuteOnKeysCodec_encodeResponse() { @Test public void test_MapForceUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 148; + int fileClientMessageIndex = 142; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapForceUnlockCodec.RequestParameters parameters = MapForceUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1350,7 +1304,7 @@ public void test_MapForceUnlockCodec_decodeRequest() { @Test public void test_MapForceUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 149; + int fileClientMessageIndex = 143; ClientMessage encoded = MapForceUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1358,7 +1312,7 @@ public void test_MapForceUnlockCodec_encodeResponse() { @Test public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 150; + int fileClientMessageIndex = 144; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapKeySetWithPagingPredicateCodec.RequestParameters parameters = MapKeySetWithPagingPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1367,7 +1321,7 @@ public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { @Test public void test_MapKeySetWithPagingPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 151; + int fileClientMessageIndex = 145; ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1375,7 +1329,7 @@ public void test_MapKeySetWithPagingPredicateCodec_encodeResponse() { @Test public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 152; + int fileClientMessageIndex = 146; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapValuesWithPagingPredicateCodec.RequestParameters parameters = MapValuesWithPagingPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1384,7 +1338,7 @@ public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { @Test public void test_MapValuesWithPagingPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 153; + int fileClientMessageIndex = 147; ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1392,7 +1346,7 @@ public void test_MapValuesWithPagingPredicateCodec_encodeResponse() { @Test public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 154; + int fileClientMessageIndex = 148; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEntriesWithPagingPredicateCodec.RequestParameters parameters = MapEntriesWithPagingPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1401,7 +1355,7 @@ public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { @Test public void test_MapEntriesWithPagingPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 155; + int fileClientMessageIndex = 149; ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeResponse(aListOfDataToData, anAnchorDataListHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1409,7 +1363,7 @@ public void test_MapEntriesWithPagingPredicateCodec_encodeResponse() { @Test public void test_MapFetchKeysCodec_decodeRequest() { - int fileClientMessageIndex = 156; + int fileClientMessageIndex = 150; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchKeysCodec.RequestParameters parameters = MapFetchKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1419,7 +1373,7 @@ public void test_MapFetchKeysCodec_decodeRequest() { @Test public void test_MapFetchKeysCodec_encodeResponse() { - int fileClientMessageIndex = 157; + int fileClientMessageIndex = 151; ClientMessage encoded = MapFetchKeysCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1427,7 +1381,7 @@ public void test_MapFetchKeysCodec_encodeResponse() { @Test public void test_MapFetchEntriesCodec_decodeRequest() { - int fileClientMessageIndex = 158; + int fileClientMessageIndex = 152; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchEntriesCodec.RequestParameters parameters = MapFetchEntriesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1437,7 +1391,7 @@ public void test_MapFetchEntriesCodec_decodeRequest() { @Test public void test_MapFetchEntriesCodec_encodeResponse() { - int fileClientMessageIndex = 159; + int fileClientMessageIndex = 153; ClientMessage encoded = MapFetchEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1445,7 +1399,7 @@ public void test_MapFetchEntriesCodec_encodeResponse() { @Test public void test_MapAggregateCodec_decodeRequest() { - int fileClientMessageIndex = 160; + int fileClientMessageIndex = 154; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAggregateCodec.RequestParameters parameters = MapAggregateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1454,7 +1408,7 @@ public void test_MapAggregateCodec_decodeRequest() { @Test public void test_MapAggregateCodec_encodeResponse() { - int fileClientMessageIndex = 161; + int fileClientMessageIndex = 155; ClientMessage encoded = MapAggregateCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1462,7 +1416,7 @@ public void test_MapAggregateCodec_encodeResponse() { @Test public void test_MapAggregateWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 162; + int fileClientMessageIndex = 156; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAggregateWithPredicateCodec.RequestParameters parameters = MapAggregateWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1472,7 +1426,7 @@ public void test_MapAggregateWithPredicateCodec_decodeRequest() { @Test public void test_MapAggregateWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 163; + int fileClientMessageIndex = 157; ClientMessage encoded = MapAggregateWithPredicateCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1480,7 +1434,7 @@ public void test_MapAggregateWithPredicateCodec_encodeResponse() { @Test public void test_MapProjectCodec_decodeRequest() { - int fileClientMessageIndex = 164; + int fileClientMessageIndex = 158; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapProjectCodec.RequestParameters parameters = MapProjectCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1489,7 +1443,7 @@ public void test_MapProjectCodec_decodeRequest() { @Test public void test_MapProjectCodec_encodeResponse() { - int fileClientMessageIndex = 165; + int fileClientMessageIndex = 159; ClientMessage encoded = MapProjectCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1497,7 +1451,7 @@ public void test_MapProjectCodec_encodeResponse() { @Test public void test_MapProjectWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 166; + int fileClientMessageIndex = 160; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapProjectWithPredicateCodec.RequestParameters parameters = MapProjectWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1507,7 +1461,7 @@ public void test_MapProjectWithPredicateCodec_decodeRequest() { @Test public void test_MapProjectWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 167; + int fileClientMessageIndex = 161; ClientMessage encoded = MapProjectWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1515,7 +1469,7 @@ public void test_MapProjectWithPredicateCodec_encodeResponse() { @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { - int fileClientMessageIndex = 168; + int fileClientMessageIndex = 162; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); assertTrue(isEqual(aListOfStrings, parameters.names)); @@ -1524,7 +1478,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeResponse() { - int fileClientMessageIndex = 169; + int fileClientMessageIndex = 163; ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1532,7 +1486,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeResponse() { @Test public void test_MapRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 170; + int fileClientMessageIndex = 164; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveAllCodec.RequestParameters parameters = MapRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1541,7 +1495,7 @@ public void test_MapRemoveAllCodec_decodeRequest() { @Test public void test_MapRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 171; + int fileClientMessageIndex = 165; ClientMessage encoded = MapRemoveAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1549,7 +1503,7 @@ public void test_MapRemoveAllCodec_encodeResponse() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { - int fileClientMessageIndex = 172; + int fileClientMessageIndex = 166; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddNearCacheInvalidationListenerCodec.RequestParameters parameters = MapAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1559,7 +1513,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeResponse() { - int fileClientMessageIndex = 173; + int fileClientMessageIndex = 167; ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1567,7 +1521,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeResponse() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidationEvent() { - int fileClientMessageIndex = 174; + int fileClientMessageIndex = 168; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapInvalidationEvent(null, aUUID, aUUID, aLong); compareClientMessages(fromFile, encoded); @@ -1575,7 +1529,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidation @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalidationEvent() { - int fileClientMessageIndex = 175; + int fileClientMessageIndex = 169; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapBatchInvalidationEvent(aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); compareClientMessages(fromFile, encoded); @@ -1583,7 +1537,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalid @Test public void test_MapFetchWithQueryCodec_decodeRequest() { - int fileClientMessageIndex = 176; + int fileClientMessageIndex = 170; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchWithQueryCodec.RequestParameters parameters = MapFetchWithQueryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1595,7 +1549,7 @@ public void test_MapFetchWithQueryCodec_decodeRequest() { @Test public void test_MapFetchWithQueryCodec_encodeResponse() { - int fileClientMessageIndex = 177; + int fileClientMessageIndex = 171; ClientMessage encoded = MapFetchWithQueryCodec.encodeResponse(aListOfData, aListOfIntegerToInteger); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1603,14 +1557,14 @@ public void test_MapFetchWithQueryCodec_encodeResponse() { @Test public void test_MapEventJournalSubscribeCodec_decodeRequest() { - int fileClientMessageIndex = 178; + int fileClientMessageIndex = 172; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapEventJournalSubscribeCodec.decodeRequest(fromFile))); } @Test public void test_MapEventJournalSubscribeCodec_encodeResponse() { - int fileClientMessageIndex = 179; + int fileClientMessageIndex = 173; ClientMessage encoded = MapEventJournalSubscribeCodec.encodeResponse(aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1618,7 +1572,7 @@ public void test_MapEventJournalSubscribeCodec_encodeResponse() { @Test public void test_MapEventJournalReadCodec_decodeRequest() { - int fileClientMessageIndex = 180; + int fileClientMessageIndex = 174; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEventJournalReadCodec.RequestParameters parameters = MapEventJournalReadCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1631,7 +1585,7 @@ public void test_MapEventJournalReadCodec_decodeRequest() { @Test public void test_MapEventJournalReadCodec_encodeResponse() { - int fileClientMessageIndex = 181; + int fileClientMessageIndex = 175; ClientMessage encoded = MapEventJournalReadCodec.encodeResponse(anInt, aListOfData, null, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1639,7 +1593,7 @@ public void test_MapEventJournalReadCodec_encodeResponse() { @Test public void test_MapSetTtlCodec_decodeRequest() { - int fileClientMessageIndex = 182; + int fileClientMessageIndex = 176; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSetTtlCodec.RequestParameters parameters = MapSetTtlCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1649,7 +1603,7 @@ public void test_MapSetTtlCodec_decodeRequest() { @Test public void test_MapSetTtlCodec_encodeResponse() { - int fileClientMessageIndex = 183; + int fileClientMessageIndex = 177; ClientMessage encoded = MapSetTtlCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1657,7 +1611,7 @@ public void test_MapSetTtlCodec_encodeResponse() { @Test public void test_MapPutWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 184; + int fileClientMessageIndex = 178; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutWithMaxIdleCodec.RequestParameters parameters = MapPutWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1670,7 +1624,7 @@ public void test_MapPutWithMaxIdleCodec_decodeRequest() { @Test public void test_MapPutWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 185; + int fileClientMessageIndex = 179; ClientMessage encoded = MapPutWithMaxIdleCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1678,7 +1632,7 @@ public void test_MapPutWithMaxIdleCodec_encodeResponse() { @Test public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 186; + int fileClientMessageIndex = 180; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutTransientWithMaxIdleCodec.RequestParameters parameters = MapPutTransientWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1691,7 +1645,7 @@ public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { @Test public void test_MapPutTransientWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 187; + int fileClientMessageIndex = 181; ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1699,7 +1653,7 @@ public void test_MapPutTransientWithMaxIdleCodec_encodeResponse() { @Test public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 188; + int fileClientMessageIndex = 182; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutIfAbsentWithMaxIdleCodec.RequestParameters parameters = MapPutIfAbsentWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1712,7 +1666,7 @@ public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { @Test public void test_MapPutIfAbsentWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 189; + int fileClientMessageIndex = 183; ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1720,7 +1674,7 @@ public void test_MapPutIfAbsentWithMaxIdleCodec_encodeResponse() { @Test public void test_MapSetWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 190; + int fileClientMessageIndex = 184; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSetWithMaxIdleCodec.RequestParameters parameters = MapSetWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1733,7 +1687,7 @@ public void test_MapSetWithMaxIdleCodec_decodeRequest() { @Test public void test_MapSetWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 191; + int fileClientMessageIndex = 185; ClientMessage encoded = MapSetWithMaxIdleCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1741,7 +1695,7 @@ public void test_MapSetWithMaxIdleCodec_encodeResponse() { @Test public void test_MultiMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 192; + int fileClientMessageIndex = 186; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapPutCodec.RequestParameters parameters = MultiMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1752,7 +1706,7 @@ public void test_MultiMapPutCodec_decodeRequest() { @Test public void test_MultiMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 193; + int fileClientMessageIndex = 187; ClientMessage encoded = MultiMapPutCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1760,7 +1714,7 @@ public void test_MultiMapPutCodec_encodeResponse() { @Test public void test_MultiMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 194; + int fileClientMessageIndex = 188; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapGetCodec.RequestParameters parameters = MultiMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1770,7 +1724,7 @@ public void test_MultiMapGetCodec_decodeRequest() { @Test public void test_MultiMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 195; + int fileClientMessageIndex = 189; ClientMessage encoded = MultiMapGetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1778,7 +1732,7 @@ public void test_MultiMapGetCodec_encodeResponse() { @Test public void test_MultiMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 196; + int fileClientMessageIndex = 190; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapRemoveCodec.RequestParameters parameters = MultiMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1788,7 +1742,7 @@ public void test_MultiMapRemoveCodec_decodeRequest() { @Test public void test_MultiMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 197; + int fileClientMessageIndex = 191; ClientMessage encoded = MultiMapRemoveCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1796,14 +1750,14 @@ public void test_MultiMapRemoveCodec_encodeResponse() { @Test public void test_MultiMapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 198; + int fileClientMessageIndex = 192; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapKeySetCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 199; + int fileClientMessageIndex = 193; ClientMessage encoded = MultiMapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1811,14 +1765,14 @@ public void test_MultiMapKeySetCodec_encodeResponse() { @Test public void test_MultiMapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 200; + int fileClientMessageIndex = 194; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapValuesCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 201; + int fileClientMessageIndex = 195; ClientMessage encoded = MultiMapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1826,14 +1780,14 @@ public void test_MultiMapValuesCodec_encodeResponse() { @Test public void test_MultiMapEntrySetCodec_decodeRequest() { - int fileClientMessageIndex = 202; + int fileClientMessageIndex = 196; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapEntrySetCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapEntrySetCodec_encodeResponse() { - int fileClientMessageIndex = 203; + int fileClientMessageIndex = 197; ClientMessage encoded = MultiMapEntrySetCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1841,7 +1795,7 @@ public void test_MultiMapEntrySetCodec_encodeResponse() { @Test public void test_MultiMapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 204; + int fileClientMessageIndex = 198; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapContainsKeyCodec.RequestParameters parameters = MultiMapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1851,7 +1805,7 @@ public void test_MultiMapContainsKeyCodec_decodeRequest() { @Test public void test_MultiMapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 205; + int fileClientMessageIndex = 199; ClientMessage encoded = MultiMapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1859,7 +1813,7 @@ public void test_MultiMapContainsKeyCodec_encodeResponse() { @Test public void test_MultiMapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 206; + int fileClientMessageIndex = 200; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapContainsValueCodec.RequestParameters parameters = MultiMapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1868,7 +1822,7 @@ public void test_MultiMapContainsValueCodec_decodeRequest() { @Test public void test_MultiMapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 207; + int fileClientMessageIndex = 201; ClientMessage encoded = MultiMapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1876,7 +1830,7 @@ public void test_MultiMapContainsValueCodec_encodeResponse() { @Test public void test_MultiMapContainsEntryCodec_decodeRequest() { - int fileClientMessageIndex = 208; + int fileClientMessageIndex = 202; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapContainsEntryCodec.RequestParameters parameters = MultiMapContainsEntryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1887,7 +1841,7 @@ public void test_MultiMapContainsEntryCodec_decodeRequest() { @Test public void test_MultiMapContainsEntryCodec_encodeResponse() { - int fileClientMessageIndex = 209; + int fileClientMessageIndex = 203; ClientMessage encoded = MultiMapContainsEntryCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1895,14 +1849,14 @@ public void test_MultiMapContainsEntryCodec_encodeResponse() { @Test public void test_MultiMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 210; + int fileClientMessageIndex = 204; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapSizeCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 211; + int fileClientMessageIndex = 205; ClientMessage encoded = MultiMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1910,14 +1864,14 @@ public void test_MultiMapSizeCodec_encodeResponse() { @Test public void test_MultiMapClearCodec_decodeRequest() { - int fileClientMessageIndex = 212; + int fileClientMessageIndex = 206; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapClearCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapClearCodec_encodeResponse() { - int fileClientMessageIndex = 213; + int fileClientMessageIndex = 207; ClientMessage encoded = MultiMapClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1925,7 +1879,7 @@ public void test_MultiMapClearCodec_encodeResponse() { @Test public void test_MultiMapValueCountCodec_decodeRequest() { - int fileClientMessageIndex = 214; + int fileClientMessageIndex = 208; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapValueCountCodec.RequestParameters parameters = MultiMapValueCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1935,7 +1889,7 @@ public void test_MultiMapValueCountCodec_decodeRequest() { @Test public void test_MultiMapValueCountCodec_encodeResponse() { - int fileClientMessageIndex = 215; + int fileClientMessageIndex = 209; ClientMessage encoded = MultiMapValueCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1943,7 +1897,7 @@ public void test_MultiMapValueCountCodec_encodeResponse() { @Test public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 216; + int fileClientMessageIndex = 210; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapAddEntryListenerToKeyCodec.RequestParameters parameters = MultiMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1954,7 +1908,7 @@ public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { @Test public void test_MultiMapAddEntryListenerToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 217; + int fileClientMessageIndex = 211; ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1962,7 +1916,7 @@ public void test_MultiMapAddEntryListenerToKeyCodec_encodeResponse() { @Test public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { - int fileClientMessageIndex = 218; + int fileClientMessageIndex = 212; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -1970,7 +1924,7 @@ public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { @Test public void test_MultiMapAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 219; + int fileClientMessageIndex = 213; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapAddEntryListenerCodec.RequestParameters parameters = MultiMapAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1980,7 +1934,7 @@ public void test_MultiMapAddEntryListenerCodec_decodeRequest() { @Test public void test_MultiMapAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 220; + int fileClientMessageIndex = 214; ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1988,7 +1942,7 @@ public void test_MultiMapAddEntryListenerCodec_encodeResponse() { @Test public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 221; + int fileClientMessageIndex = 215; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -1996,7 +1950,7 @@ public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { @Test public void test_MultiMapRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 222; + int fileClientMessageIndex = 216; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapRemoveEntryListenerCodec.RequestParameters parameters = MultiMapRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2005,7 +1959,7 @@ public void test_MultiMapRemoveEntryListenerCodec_decodeRequest() { @Test public void test_MultiMapRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 223; + int fileClientMessageIndex = 217; ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2013,7 +1967,7 @@ public void test_MultiMapRemoveEntryListenerCodec_encodeResponse() { @Test public void test_MultiMapLockCodec_decodeRequest() { - int fileClientMessageIndex = 224; + int fileClientMessageIndex = 218; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapLockCodec.RequestParameters parameters = MultiMapLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2025,7 +1979,7 @@ public void test_MultiMapLockCodec_decodeRequest() { @Test public void test_MultiMapLockCodec_encodeResponse() { - int fileClientMessageIndex = 225; + int fileClientMessageIndex = 219; ClientMessage encoded = MultiMapLockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2033,7 +1987,7 @@ public void test_MultiMapLockCodec_encodeResponse() { @Test public void test_MultiMapTryLockCodec_decodeRequest() { - int fileClientMessageIndex = 226; + int fileClientMessageIndex = 220; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapTryLockCodec.RequestParameters parameters = MultiMapTryLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2046,7 +2000,7 @@ public void test_MultiMapTryLockCodec_decodeRequest() { @Test public void test_MultiMapTryLockCodec_encodeResponse() { - int fileClientMessageIndex = 227; + int fileClientMessageIndex = 221; ClientMessage encoded = MultiMapTryLockCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2054,7 +2008,7 @@ public void test_MultiMapTryLockCodec_encodeResponse() { @Test public void test_MultiMapIsLockedCodec_decodeRequest() { - int fileClientMessageIndex = 228; + int fileClientMessageIndex = 222; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapIsLockedCodec.RequestParameters parameters = MultiMapIsLockedCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2063,7 +2017,7 @@ public void test_MultiMapIsLockedCodec_decodeRequest() { @Test public void test_MultiMapIsLockedCodec_encodeResponse() { - int fileClientMessageIndex = 229; + int fileClientMessageIndex = 223; ClientMessage encoded = MultiMapIsLockedCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2071,7 +2025,7 @@ public void test_MultiMapIsLockedCodec_encodeResponse() { @Test public void test_MultiMapUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 230; + int fileClientMessageIndex = 224; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapUnlockCodec.RequestParameters parameters = MultiMapUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2082,7 +2036,7 @@ public void test_MultiMapUnlockCodec_decodeRequest() { @Test public void test_MultiMapUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 231; + int fileClientMessageIndex = 225; ClientMessage encoded = MultiMapUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2090,7 +2044,7 @@ public void test_MultiMapUnlockCodec_encodeResponse() { @Test public void test_MultiMapForceUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 232; + int fileClientMessageIndex = 226; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapForceUnlockCodec.RequestParameters parameters = MultiMapForceUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2100,7 +2054,7 @@ public void test_MultiMapForceUnlockCodec_decodeRequest() { @Test public void test_MultiMapForceUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 233; + int fileClientMessageIndex = 227; ClientMessage encoded = MultiMapForceUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2108,7 +2062,7 @@ public void test_MultiMapForceUnlockCodec_encodeResponse() { @Test public void test_MultiMapRemoveEntryCodec_decodeRequest() { - int fileClientMessageIndex = 234; + int fileClientMessageIndex = 228; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapRemoveEntryCodec.RequestParameters parameters = MultiMapRemoveEntryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2119,7 +2073,7 @@ public void test_MultiMapRemoveEntryCodec_decodeRequest() { @Test public void test_MultiMapRemoveEntryCodec_encodeResponse() { - int fileClientMessageIndex = 235; + int fileClientMessageIndex = 229; ClientMessage encoded = MultiMapRemoveEntryCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2127,7 +2081,7 @@ public void test_MultiMapRemoveEntryCodec_encodeResponse() { @Test public void test_MultiMapDeleteCodec_decodeRequest() { - int fileClientMessageIndex = 236; + int fileClientMessageIndex = 230; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapDeleteCodec.RequestParameters parameters = MultiMapDeleteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2137,7 +2091,7 @@ public void test_MultiMapDeleteCodec_decodeRequest() { @Test public void test_MultiMapDeleteCodec_encodeResponse() { - int fileClientMessageIndex = 237; + int fileClientMessageIndex = 231; ClientMessage encoded = MultiMapDeleteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2145,7 +2099,7 @@ public void test_MultiMapDeleteCodec_encodeResponse() { @Test public void test_MultiMapPutAllCodec_decodeRequest() { - int fileClientMessageIndex = 238; + int fileClientMessageIndex = 232; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapPutAllCodec.RequestParameters parameters = MultiMapPutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2154,7 +2108,7 @@ public void test_MultiMapPutAllCodec_decodeRequest() { @Test public void test_MultiMapPutAllCodec_encodeResponse() { - int fileClientMessageIndex = 239; + int fileClientMessageIndex = 233; ClientMessage encoded = MultiMapPutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2162,7 +2116,7 @@ public void test_MultiMapPutAllCodec_encodeResponse() { @Test public void test_QueueOfferCodec_decodeRequest() { - int fileClientMessageIndex = 240; + int fileClientMessageIndex = 234; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueOfferCodec.RequestParameters parameters = QueueOfferCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2172,7 +2126,7 @@ public void test_QueueOfferCodec_decodeRequest() { @Test public void test_QueueOfferCodec_encodeResponse() { - int fileClientMessageIndex = 241; + int fileClientMessageIndex = 235; ClientMessage encoded = QueueOfferCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2180,7 +2134,7 @@ public void test_QueueOfferCodec_encodeResponse() { @Test public void test_QueuePutCodec_decodeRequest() { - int fileClientMessageIndex = 242; + int fileClientMessageIndex = 236; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueuePutCodec.RequestParameters parameters = QueuePutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2189,7 +2143,7 @@ public void test_QueuePutCodec_decodeRequest() { @Test public void test_QueuePutCodec_encodeResponse() { - int fileClientMessageIndex = 243; + int fileClientMessageIndex = 237; ClientMessage encoded = QueuePutCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2197,14 +2151,14 @@ public void test_QueuePutCodec_encodeResponse() { @Test public void test_QueueSizeCodec_decodeRequest() { - int fileClientMessageIndex = 244; + int fileClientMessageIndex = 238; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueSizeCodec.decodeRequest(fromFile))); } @Test public void test_QueueSizeCodec_encodeResponse() { - int fileClientMessageIndex = 245; + int fileClientMessageIndex = 239; ClientMessage encoded = QueueSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2212,7 +2166,7 @@ public void test_QueueSizeCodec_encodeResponse() { @Test public void test_QueueRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 246; + int fileClientMessageIndex = 240; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueRemoveCodec.RequestParameters parameters = QueueRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2221,7 +2175,7 @@ public void test_QueueRemoveCodec_decodeRequest() { @Test public void test_QueueRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 247; + int fileClientMessageIndex = 241; ClientMessage encoded = QueueRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2229,7 +2183,7 @@ public void test_QueueRemoveCodec_encodeResponse() { @Test public void test_QueuePollCodec_decodeRequest() { - int fileClientMessageIndex = 248; + int fileClientMessageIndex = 242; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueuePollCodec.RequestParameters parameters = QueuePollCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2238,7 +2192,7 @@ public void test_QueuePollCodec_decodeRequest() { @Test public void test_QueuePollCodec_encodeResponse() { - int fileClientMessageIndex = 249; + int fileClientMessageIndex = 243; ClientMessage encoded = QueuePollCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2246,14 +2200,14 @@ public void test_QueuePollCodec_encodeResponse() { @Test public void test_QueueTakeCodec_decodeRequest() { - int fileClientMessageIndex = 250; + int fileClientMessageIndex = 244; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueTakeCodec.decodeRequest(fromFile))); } @Test public void test_QueueTakeCodec_encodeResponse() { - int fileClientMessageIndex = 251; + int fileClientMessageIndex = 245; ClientMessage encoded = QueueTakeCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2261,14 +2215,14 @@ public void test_QueueTakeCodec_encodeResponse() { @Test public void test_QueuePeekCodec_decodeRequest() { - int fileClientMessageIndex = 252; + int fileClientMessageIndex = 246; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueuePeekCodec.decodeRequest(fromFile))); } @Test public void test_QueuePeekCodec_encodeResponse() { - int fileClientMessageIndex = 253; + int fileClientMessageIndex = 247; ClientMessage encoded = QueuePeekCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2276,14 +2230,14 @@ public void test_QueuePeekCodec_encodeResponse() { @Test public void test_QueueIteratorCodec_decodeRequest() { - int fileClientMessageIndex = 254; + int fileClientMessageIndex = 248; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueIteratorCodec.decodeRequest(fromFile))); } @Test public void test_QueueIteratorCodec_encodeResponse() { - int fileClientMessageIndex = 255; + int fileClientMessageIndex = 249; ClientMessage encoded = QueueIteratorCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2291,14 +2245,14 @@ public void test_QueueIteratorCodec_encodeResponse() { @Test public void test_QueueDrainToCodec_decodeRequest() { - int fileClientMessageIndex = 256; + int fileClientMessageIndex = 250; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueDrainToCodec.decodeRequest(fromFile))); } @Test public void test_QueueDrainToCodec_encodeResponse() { - int fileClientMessageIndex = 257; + int fileClientMessageIndex = 251; ClientMessage encoded = QueueDrainToCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2306,7 +2260,7 @@ public void test_QueueDrainToCodec_encodeResponse() { @Test public void test_QueueDrainToMaxSizeCodec_decodeRequest() { - int fileClientMessageIndex = 258; + int fileClientMessageIndex = 252; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueDrainToMaxSizeCodec.RequestParameters parameters = QueueDrainToMaxSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2315,7 +2269,7 @@ public void test_QueueDrainToMaxSizeCodec_decodeRequest() { @Test public void test_QueueDrainToMaxSizeCodec_encodeResponse() { - int fileClientMessageIndex = 259; + int fileClientMessageIndex = 253; ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2323,7 +2277,7 @@ public void test_QueueDrainToMaxSizeCodec_encodeResponse() { @Test public void test_QueueContainsCodec_decodeRequest() { - int fileClientMessageIndex = 260; + int fileClientMessageIndex = 254; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueContainsCodec.RequestParameters parameters = QueueContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2332,7 +2286,7 @@ public void test_QueueContainsCodec_decodeRequest() { @Test public void test_QueueContainsCodec_encodeResponse() { - int fileClientMessageIndex = 261; + int fileClientMessageIndex = 255; ClientMessage encoded = QueueContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2340,7 +2294,7 @@ public void test_QueueContainsCodec_encodeResponse() { @Test public void test_QueueContainsAllCodec_decodeRequest() { - int fileClientMessageIndex = 262; + int fileClientMessageIndex = 256; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueContainsAllCodec.RequestParameters parameters = QueueContainsAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2349,7 +2303,7 @@ public void test_QueueContainsAllCodec_decodeRequest() { @Test public void test_QueueContainsAllCodec_encodeResponse() { - int fileClientMessageIndex = 263; + int fileClientMessageIndex = 257; ClientMessage encoded = QueueContainsAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2357,7 +2311,7 @@ public void test_QueueContainsAllCodec_encodeResponse() { @Test public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 264; + int fileClientMessageIndex = 258; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueCompareAndRemoveAllCodec.RequestParameters parameters = QueueCompareAndRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2366,7 +2320,7 @@ public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { @Test public void test_QueueCompareAndRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 265; + int fileClientMessageIndex = 259; ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2374,7 +2328,7 @@ public void test_QueueCompareAndRemoveAllCodec_encodeResponse() { @Test public void test_QueueCompareAndRetainAllCodec_decodeRequest() { - int fileClientMessageIndex = 266; + int fileClientMessageIndex = 260; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueCompareAndRetainAllCodec.RequestParameters parameters = QueueCompareAndRetainAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2383,7 +2337,7 @@ public void test_QueueCompareAndRetainAllCodec_decodeRequest() { @Test public void test_QueueCompareAndRetainAllCodec_encodeResponse() { - int fileClientMessageIndex = 267; + int fileClientMessageIndex = 261; ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2391,14 +2345,14 @@ public void test_QueueCompareAndRetainAllCodec_encodeResponse() { @Test public void test_QueueClearCodec_decodeRequest() { - int fileClientMessageIndex = 268; + int fileClientMessageIndex = 262; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueClearCodec.decodeRequest(fromFile))); } @Test public void test_QueueClearCodec_encodeResponse() { - int fileClientMessageIndex = 269; + int fileClientMessageIndex = 263; ClientMessage encoded = QueueClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2406,7 +2360,7 @@ public void test_QueueClearCodec_encodeResponse() { @Test public void test_QueueAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 270; + int fileClientMessageIndex = 264; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueAddAllCodec.RequestParameters parameters = QueueAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2415,7 +2369,7 @@ public void test_QueueAddAllCodec_decodeRequest() { @Test public void test_QueueAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 271; + int fileClientMessageIndex = 265; ClientMessage encoded = QueueAddAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2423,7 +2377,7 @@ public void test_QueueAddAllCodec_encodeResponse() { @Test public void test_QueueAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 272; + int fileClientMessageIndex = 266; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueAddListenerCodec.RequestParameters parameters = QueueAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2433,7 +2387,7 @@ public void test_QueueAddListenerCodec_decodeRequest() { @Test public void test_QueueAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 273; + int fileClientMessageIndex = 267; ClientMessage encoded = QueueAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2441,7 +2395,7 @@ public void test_QueueAddListenerCodec_encodeResponse() { @Test public void test_QueueAddListenerCodec_encodeItemEvent() { - int fileClientMessageIndex = 274; + int fileClientMessageIndex = 268; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = QueueAddListenerCodec.encodeItemEvent(null, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -2449,7 +2403,7 @@ public void test_QueueAddListenerCodec_encodeItemEvent() { @Test public void test_QueueRemoveListenerCodec_decodeRequest() { - int fileClientMessageIndex = 275; + int fileClientMessageIndex = 269; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueRemoveListenerCodec.RequestParameters parameters = QueueRemoveListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2458,7 +2412,7 @@ public void test_QueueRemoveListenerCodec_decodeRequest() { @Test public void test_QueueRemoveListenerCodec_encodeResponse() { - int fileClientMessageIndex = 276; + int fileClientMessageIndex = 270; ClientMessage encoded = QueueRemoveListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2466,14 +2420,14 @@ public void test_QueueRemoveListenerCodec_encodeResponse() { @Test public void test_QueueRemainingCapacityCodec_decodeRequest() { - int fileClientMessageIndex = 277; + int fileClientMessageIndex = 271; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueRemainingCapacityCodec.decodeRequest(fromFile))); } @Test public void test_QueueRemainingCapacityCodec_encodeResponse() { - int fileClientMessageIndex = 278; + int fileClientMessageIndex = 272; ClientMessage encoded = QueueRemainingCapacityCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2481,14 +2435,14 @@ public void test_QueueRemainingCapacityCodec_encodeResponse() { @Test public void test_QueueIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 279; + int fileClientMessageIndex = 273; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_QueueIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 280; + int fileClientMessageIndex = 274; ClientMessage encoded = QueueIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2496,7 +2450,7 @@ public void test_QueueIsEmptyCodec_encodeResponse() { @Test public void test_TopicPublishCodec_decodeRequest() { - int fileClientMessageIndex = 281; + int fileClientMessageIndex = 275; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicPublishCodec.RequestParameters parameters = TopicPublishCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2505,7 +2459,7 @@ public void test_TopicPublishCodec_decodeRequest() { @Test public void test_TopicPublishCodec_encodeResponse() { - int fileClientMessageIndex = 282; + int fileClientMessageIndex = 276; ClientMessage encoded = TopicPublishCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2513,7 +2467,7 @@ public void test_TopicPublishCodec_encodeResponse() { @Test public void test_TopicAddMessageListenerCodec_decodeRequest() { - int fileClientMessageIndex = 283; + int fileClientMessageIndex = 277; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicAddMessageListenerCodec.RequestParameters parameters = TopicAddMessageListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2522,7 +2476,7 @@ public void test_TopicAddMessageListenerCodec_decodeRequest() { @Test public void test_TopicAddMessageListenerCodec_encodeResponse() { - int fileClientMessageIndex = 284; + int fileClientMessageIndex = 278; ClientMessage encoded = TopicAddMessageListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2530,7 +2484,7 @@ public void test_TopicAddMessageListenerCodec_encodeResponse() { @Test public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { - int fileClientMessageIndex = 285; + int fileClientMessageIndex = 279; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = TopicAddMessageListenerCodec.encodeTopicEvent(aData, aLong, aUUID); compareClientMessages(fromFile, encoded); @@ -2538,7 +2492,7 @@ public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { @Test public void test_TopicRemoveMessageListenerCodec_decodeRequest() { - int fileClientMessageIndex = 286; + int fileClientMessageIndex = 280; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicRemoveMessageListenerCodec.RequestParameters parameters = TopicRemoveMessageListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2547,7 +2501,7 @@ public void test_TopicRemoveMessageListenerCodec_decodeRequest() { @Test public void test_TopicRemoveMessageListenerCodec_encodeResponse() { - int fileClientMessageIndex = 287; + int fileClientMessageIndex = 281; ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2555,7 +2509,7 @@ public void test_TopicRemoveMessageListenerCodec_encodeResponse() { @Test public void test_TopicPublishAllCodec_decodeRequest() { - int fileClientMessageIndex = 288; + int fileClientMessageIndex = 282; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicPublishAllCodec.RequestParameters parameters = TopicPublishAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2564,7 +2518,7 @@ public void test_TopicPublishAllCodec_decodeRequest() { @Test public void test_TopicPublishAllCodec_encodeResponse() { - int fileClientMessageIndex = 289; + int fileClientMessageIndex = 283; ClientMessage encoded = TopicPublishAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2572,14 +2526,14 @@ public void test_TopicPublishAllCodec_encodeResponse() { @Test public void test_ListSizeCodec_decodeRequest() { - int fileClientMessageIndex = 290; + int fileClientMessageIndex = 284; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListSizeCodec.decodeRequest(fromFile))); } @Test public void test_ListSizeCodec_encodeResponse() { - int fileClientMessageIndex = 291; + int fileClientMessageIndex = 285; ClientMessage encoded = ListSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2587,7 +2541,7 @@ public void test_ListSizeCodec_encodeResponse() { @Test public void test_ListContainsCodec_decodeRequest() { - int fileClientMessageIndex = 292; + int fileClientMessageIndex = 286; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListContainsCodec.RequestParameters parameters = ListContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2596,7 +2550,7 @@ public void test_ListContainsCodec_decodeRequest() { @Test public void test_ListContainsCodec_encodeResponse() { - int fileClientMessageIndex = 293; + int fileClientMessageIndex = 287; ClientMessage encoded = ListContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2604,7 +2558,7 @@ public void test_ListContainsCodec_encodeResponse() { @Test public void test_ListContainsAllCodec_decodeRequest() { - int fileClientMessageIndex = 294; + int fileClientMessageIndex = 288; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListContainsAllCodec.RequestParameters parameters = ListContainsAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2613,7 +2567,7 @@ public void test_ListContainsAllCodec_decodeRequest() { @Test public void test_ListContainsAllCodec_encodeResponse() { - int fileClientMessageIndex = 295; + int fileClientMessageIndex = 289; ClientMessage encoded = ListContainsAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2621,7 +2575,7 @@ public void test_ListContainsAllCodec_encodeResponse() { @Test public void test_ListAddCodec_decodeRequest() { - int fileClientMessageIndex = 296; + int fileClientMessageIndex = 290; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddCodec.RequestParameters parameters = ListAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2630,7 +2584,7 @@ public void test_ListAddCodec_decodeRequest() { @Test public void test_ListAddCodec_encodeResponse() { - int fileClientMessageIndex = 297; + int fileClientMessageIndex = 291; ClientMessage encoded = ListAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2638,7 +2592,7 @@ public void test_ListAddCodec_encodeResponse() { @Test public void test_ListRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 298; + int fileClientMessageIndex = 292; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListRemoveCodec.RequestParameters parameters = ListRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2647,7 +2601,7 @@ public void test_ListRemoveCodec_decodeRequest() { @Test public void test_ListRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 299; + int fileClientMessageIndex = 293; ClientMessage encoded = ListRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2655,7 +2609,7 @@ public void test_ListRemoveCodec_encodeResponse() { @Test public void test_ListAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 300; + int fileClientMessageIndex = 294; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddAllCodec.RequestParameters parameters = ListAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2664,7 +2618,7 @@ public void test_ListAddAllCodec_decodeRequest() { @Test public void test_ListAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 301; + int fileClientMessageIndex = 295; ClientMessage encoded = ListAddAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2672,7 +2626,7 @@ public void test_ListAddAllCodec_encodeResponse() { @Test public void test_ListCompareAndRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 302; + int fileClientMessageIndex = 296; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListCompareAndRemoveAllCodec.RequestParameters parameters = ListCompareAndRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2681,7 +2635,7 @@ public void test_ListCompareAndRemoveAllCodec_decodeRequest() { @Test public void test_ListCompareAndRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 303; + int fileClientMessageIndex = 297; ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2689,7 +2643,7 @@ public void test_ListCompareAndRemoveAllCodec_encodeResponse() { @Test public void test_ListCompareAndRetainAllCodec_decodeRequest() { - int fileClientMessageIndex = 304; + int fileClientMessageIndex = 298; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListCompareAndRetainAllCodec.RequestParameters parameters = ListCompareAndRetainAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2698,7 +2652,7 @@ public void test_ListCompareAndRetainAllCodec_decodeRequest() { @Test public void test_ListCompareAndRetainAllCodec_encodeResponse() { - int fileClientMessageIndex = 305; + int fileClientMessageIndex = 299; ClientMessage encoded = ListCompareAndRetainAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2706,14 +2660,14 @@ public void test_ListCompareAndRetainAllCodec_encodeResponse() { @Test public void test_ListClearCodec_decodeRequest() { - int fileClientMessageIndex = 306; + int fileClientMessageIndex = 300; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListClearCodec.decodeRequest(fromFile))); } @Test public void test_ListClearCodec_encodeResponse() { - int fileClientMessageIndex = 307; + int fileClientMessageIndex = 301; ClientMessage encoded = ListClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2721,14 +2675,14 @@ public void test_ListClearCodec_encodeResponse() { @Test public void test_ListGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 308; + int fileClientMessageIndex = 302; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListGetAllCodec.decodeRequest(fromFile))); } @Test public void test_ListGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 309; + int fileClientMessageIndex = 303; ClientMessage encoded = ListGetAllCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2736,7 +2690,7 @@ public void test_ListGetAllCodec_encodeResponse() { @Test public void test_ListAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 310; + int fileClientMessageIndex = 304; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddListenerCodec.RequestParameters parameters = ListAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2746,7 +2700,7 @@ public void test_ListAddListenerCodec_decodeRequest() { @Test public void test_ListAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 311; + int fileClientMessageIndex = 305; ClientMessage encoded = ListAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2754,7 +2708,7 @@ public void test_ListAddListenerCodec_encodeResponse() { @Test public void test_ListAddListenerCodec_encodeItemEvent() { - int fileClientMessageIndex = 312; + int fileClientMessageIndex = 306; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ListAddListenerCodec.encodeItemEvent(null, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -2762,7 +2716,7 @@ public void test_ListAddListenerCodec_encodeItemEvent() { @Test public void test_ListRemoveListenerCodec_decodeRequest() { - int fileClientMessageIndex = 313; + int fileClientMessageIndex = 307; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListRemoveListenerCodec.RequestParameters parameters = ListRemoveListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2771,7 +2725,7 @@ public void test_ListRemoveListenerCodec_decodeRequest() { @Test public void test_ListRemoveListenerCodec_encodeResponse() { - int fileClientMessageIndex = 314; + int fileClientMessageIndex = 308; ClientMessage encoded = ListRemoveListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2779,14 +2733,14 @@ public void test_ListRemoveListenerCodec_encodeResponse() { @Test public void test_ListIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 315; + int fileClientMessageIndex = 309; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_ListIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 316; + int fileClientMessageIndex = 310; ClientMessage encoded = ListIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2794,7 +2748,7 @@ public void test_ListIsEmptyCodec_encodeResponse() { @Test public void test_ListAddAllWithIndexCodec_decodeRequest() { - int fileClientMessageIndex = 317; + int fileClientMessageIndex = 311; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddAllWithIndexCodec.RequestParameters parameters = ListAddAllWithIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2804,7 +2758,7 @@ public void test_ListAddAllWithIndexCodec_decodeRequest() { @Test public void test_ListAddAllWithIndexCodec_encodeResponse() { - int fileClientMessageIndex = 318; + int fileClientMessageIndex = 312; ClientMessage encoded = ListAddAllWithIndexCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2812,7 +2766,7 @@ public void test_ListAddAllWithIndexCodec_encodeResponse() { @Test public void test_ListGetCodec_decodeRequest() { - int fileClientMessageIndex = 319; + int fileClientMessageIndex = 313; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListGetCodec.RequestParameters parameters = ListGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2821,7 +2775,7 @@ public void test_ListGetCodec_decodeRequest() { @Test public void test_ListGetCodec_encodeResponse() { - int fileClientMessageIndex = 320; + int fileClientMessageIndex = 314; ClientMessage encoded = ListGetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2829,7 +2783,7 @@ public void test_ListGetCodec_encodeResponse() { @Test public void test_ListSetCodec_decodeRequest() { - int fileClientMessageIndex = 321; + int fileClientMessageIndex = 315; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListSetCodec.RequestParameters parameters = ListSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2839,7 +2793,7 @@ public void test_ListSetCodec_decodeRequest() { @Test public void test_ListSetCodec_encodeResponse() { - int fileClientMessageIndex = 322; + int fileClientMessageIndex = 316; ClientMessage encoded = ListSetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2847,7 +2801,7 @@ public void test_ListSetCodec_encodeResponse() { @Test public void test_ListAddWithIndexCodec_decodeRequest() { - int fileClientMessageIndex = 323; + int fileClientMessageIndex = 317; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddWithIndexCodec.RequestParameters parameters = ListAddWithIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2857,7 +2811,7 @@ public void test_ListAddWithIndexCodec_decodeRequest() { @Test public void test_ListAddWithIndexCodec_encodeResponse() { - int fileClientMessageIndex = 324; + int fileClientMessageIndex = 318; ClientMessage encoded = ListAddWithIndexCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2865,7 +2819,7 @@ public void test_ListAddWithIndexCodec_encodeResponse() { @Test public void test_ListRemoveWithIndexCodec_decodeRequest() { - int fileClientMessageIndex = 325; + int fileClientMessageIndex = 319; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListRemoveWithIndexCodec.RequestParameters parameters = ListRemoveWithIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2874,7 +2828,7 @@ public void test_ListRemoveWithIndexCodec_decodeRequest() { @Test public void test_ListRemoveWithIndexCodec_encodeResponse() { - int fileClientMessageIndex = 326; + int fileClientMessageIndex = 320; ClientMessage encoded = ListRemoveWithIndexCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2882,7 +2836,7 @@ public void test_ListRemoveWithIndexCodec_encodeResponse() { @Test public void test_ListLastIndexOfCodec_decodeRequest() { - int fileClientMessageIndex = 327; + int fileClientMessageIndex = 321; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListLastIndexOfCodec.RequestParameters parameters = ListLastIndexOfCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2891,7 +2845,7 @@ public void test_ListLastIndexOfCodec_decodeRequest() { @Test public void test_ListLastIndexOfCodec_encodeResponse() { - int fileClientMessageIndex = 328; + int fileClientMessageIndex = 322; ClientMessage encoded = ListLastIndexOfCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2899,7 +2853,7 @@ public void test_ListLastIndexOfCodec_encodeResponse() { @Test public void test_ListIndexOfCodec_decodeRequest() { - int fileClientMessageIndex = 329; + int fileClientMessageIndex = 323; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListIndexOfCodec.RequestParameters parameters = ListIndexOfCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2908,7 +2862,7 @@ public void test_ListIndexOfCodec_decodeRequest() { @Test public void test_ListIndexOfCodec_encodeResponse() { - int fileClientMessageIndex = 330; + int fileClientMessageIndex = 324; ClientMessage encoded = ListIndexOfCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2916,7 +2870,7 @@ public void test_ListIndexOfCodec_encodeResponse() { @Test public void test_ListSubCodec_decodeRequest() { - int fileClientMessageIndex = 331; + int fileClientMessageIndex = 325; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListSubCodec.RequestParameters parameters = ListSubCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2926,7 +2880,7 @@ public void test_ListSubCodec_decodeRequest() { @Test public void test_ListSubCodec_encodeResponse() { - int fileClientMessageIndex = 332; + int fileClientMessageIndex = 326; ClientMessage encoded = ListSubCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2934,14 +2888,14 @@ public void test_ListSubCodec_encodeResponse() { @Test public void test_ListIteratorCodec_decodeRequest() { - int fileClientMessageIndex = 333; + int fileClientMessageIndex = 327; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListIteratorCodec.decodeRequest(fromFile))); } @Test public void test_ListIteratorCodec_encodeResponse() { - int fileClientMessageIndex = 334; + int fileClientMessageIndex = 328; ClientMessage encoded = ListIteratorCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2949,7 +2903,7 @@ public void test_ListIteratorCodec_encodeResponse() { @Test public void test_ListListIteratorCodec_decodeRequest() { - int fileClientMessageIndex = 335; + int fileClientMessageIndex = 329; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListListIteratorCodec.RequestParameters parameters = ListListIteratorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2958,7 +2912,7 @@ public void test_ListListIteratorCodec_decodeRequest() { @Test public void test_ListListIteratorCodec_encodeResponse() { - int fileClientMessageIndex = 336; + int fileClientMessageIndex = 330; ClientMessage encoded = ListListIteratorCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2966,14 +2920,14 @@ public void test_ListListIteratorCodec_encodeResponse() { @Test public void test_SetSizeCodec_decodeRequest() { - int fileClientMessageIndex = 337; + int fileClientMessageIndex = 331; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetSizeCodec.decodeRequest(fromFile))); } @Test public void test_SetSizeCodec_encodeResponse() { - int fileClientMessageIndex = 338; + int fileClientMessageIndex = 332; ClientMessage encoded = SetSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2981,7 +2935,7 @@ public void test_SetSizeCodec_encodeResponse() { @Test public void test_SetContainsCodec_decodeRequest() { - int fileClientMessageIndex = 339; + int fileClientMessageIndex = 333; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetContainsCodec.RequestParameters parameters = SetContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2990,7 +2944,7 @@ public void test_SetContainsCodec_decodeRequest() { @Test public void test_SetContainsCodec_encodeResponse() { - int fileClientMessageIndex = 340; + int fileClientMessageIndex = 334; ClientMessage encoded = SetContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2998,7 +2952,7 @@ public void test_SetContainsCodec_encodeResponse() { @Test public void test_SetContainsAllCodec_decodeRequest() { - int fileClientMessageIndex = 341; + int fileClientMessageIndex = 335; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetContainsAllCodec.RequestParameters parameters = SetContainsAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3007,7 +2961,7 @@ public void test_SetContainsAllCodec_decodeRequest() { @Test public void test_SetContainsAllCodec_encodeResponse() { - int fileClientMessageIndex = 342; + int fileClientMessageIndex = 336; ClientMessage encoded = SetContainsAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3015,7 +2969,7 @@ public void test_SetContainsAllCodec_encodeResponse() { @Test public void test_SetAddCodec_decodeRequest() { - int fileClientMessageIndex = 343; + int fileClientMessageIndex = 337; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetAddCodec.RequestParameters parameters = SetAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3024,7 +2978,7 @@ public void test_SetAddCodec_decodeRequest() { @Test public void test_SetAddCodec_encodeResponse() { - int fileClientMessageIndex = 344; + int fileClientMessageIndex = 338; ClientMessage encoded = SetAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3032,7 +2986,7 @@ public void test_SetAddCodec_encodeResponse() { @Test public void test_SetRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 345; + int fileClientMessageIndex = 339; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetRemoveCodec.RequestParameters parameters = SetRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3041,7 +2995,7 @@ public void test_SetRemoveCodec_decodeRequest() { @Test public void test_SetRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 346; + int fileClientMessageIndex = 340; ClientMessage encoded = SetRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3049,7 +3003,7 @@ public void test_SetRemoveCodec_encodeResponse() { @Test public void test_SetAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 347; + int fileClientMessageIndex = 341; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetAddAllCodec.RequestParameters parameters = SetAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3058,7 +3012,7 @@ public void test_SetAddAllCodec_decodeRequest() { @Test public void test_SetAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 348; + int fileClientMessageIndex = 342; ClientMessage encoded = SetAddAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3066,7 +3020,7 @@ public void test_SetAddAllCodec_encodeResponse() { @Test public void test_SetCompareAndRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 349; + int fileClientMessageIndex = 343; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetCompareAndRemoveAllCodec.RequestParameters parameters = SetCompareAndRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3075,7 +3029,7 @@ public void test_SetCompareAndRemoveAllCodec_decodeRequest() { @Test public void test_SetCompareAndRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 350; + int fileClientMessageIndex = 344; ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3083,7 +3037,7 @@ public void test_SetCompareAndRemoveAllCodec_encodeResponse() { @Test public void test_SetCompareAndRetainAllCodec_decodeRequest() { - int fileClientMessageIndex = 351; + int fileClientMessageIndex = 345; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetCompareAndRetainAllCodec.RequestParameters parameters = SetCompareAndRetainAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3092,7 +3046,7 @@ public void test_SetCompareAndRetainAllCodec_decodeRequest() { @Test public void test_SetCompareAndRetainAllCodec_encodeResponse() { - int fileClientMessageIndex = 352; + int fileClientMessageIndex = 346; ClientMessage encoded = SetCompareAndRetainAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3100,14 +3054,14 @@ public void test_SetCompareAndRetainAllCodec_encodeResponse() { @Test public void test_SetClearCodec_decodeRequest() { - int fileClientMessageIndex = 353; + int fileClientMessageIndex = 347; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetClearCodec.decodeRequest(fromFile))); } @Test public void test_SetClearCodec_encodeResponse() { - int fileClientMessageIndex = 354; + int fileClientMessageIndex = 348; ClientMessage encoded = SetClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3115,14 +3069,14 @@ public void test_SetClearCodec_encodeResponse() { @Test public void test_SetGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 355; + int fileClientMessageIndex = 349; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetGetAllCodec.decodeRequest(fromFile))); } @Test public void test_SetGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 356; + int fileClientMessageIndex = 350; ClientMessage encoded = SetGetAllCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3130,7 +3084,7 @@ public void test_SetGetAllCodec_encodeResponse() { @Test public void test_SetAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 357; + int fileClientMessageIndex = 351; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetAddListenerCodec.RequestParameters parameters = SetAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3140,7 +3094,7 @@ public void test_SetAddListenerCodec_decodeRequest() { @Test public void test_SetAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 358; + int fileClientMessageIndex = 352; ClientMessage encoded = SetAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3148,7 +3102,7 @@ public void test_SetAddListenerCodec_encodeResponse() { @Test public void test_SetAddListenerCodec_encodeItemEvent() { - int fileClientMessageIndex = 359; + int fileClientMessageIndex = 353; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = SetAddListenerCodec.encodeItemEvent(null, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -3156,7 +3110,7 @@ public void test_SetAddListenerCodec_encodeItemEvent() { @Test public void test_SetRemoveListenerCodec_decodeRequest() { - int fileClientMessageIndex = 360; + int fileClientMessageIndex = 354; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetRemoveListenerCodec.RequestParameters parameters = SetRemoveListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3165,7 +3119,7 @@ public void test_SetRemoveListenerCodec_decodeRequest() { @Test public void test_SetRemoveListenerCodec_encodeResponse() { - int fileClientMessageIndex = 361; + int fileClientMessageIndex = 355; ClientMessage encoded = SetRemoveListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3173,14 +3127,14 @@ public void test_SetRemoveListenerCodec_encodeResponse() { @Test public void test_SetIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 362; + int fileClientMessageIndex = 356; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_SetIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 363; + int fileClientMessageIndex = 357; ClientMessage encoded = SetIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3188,7 +3142,7 @@ public void test_SetIsEmptyCodec_encodeResponse() { @Test public void test_FencedLockLockCodec_decodeRequest() { - int fileClientMessageIndex = 364; + int fileClientMessageIndex = 358; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockLockCodec.RequestParameters parameters = FencedLockLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3200,7 +3154,7 @@ public void test_FencedLockLockCodec_decodeRequest() { @Test public void test_FencedLockLockCodec_encodeResponse() { - int fileClientMessageIndex = 365; + int fileClientMessageIndex = 359; ClientMessage encoded = FencedLockLockCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3208,7 +3162,7 @@ public void test_FencedLockLockCodec_encodeResponse() { @Test public void test_FencedLockTryLockCodec_decodeRequest() { - int fileClientMessageIndex = 366; + int fileClientMessageIndex = 360; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockTryLockCodec.RequestParameters parameters = FencedLockTryLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3221,7 +3175,7 @@ public void test_FencedLockTryLockCodec_decodeRequest() { @Test public void test_FencedLockTryLockCodec_encodeResponse() { - int fileClientMessageIndex = 367; + int fileClientMessageIndex = 361; ClientMessage encoded = FencedLockTryLockCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3229,7 +3183,7 @@ public void test_FencedLockTryLockCodec_encodeResponse() { @Test public void test_FencedLockUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 368; + int fileClientMessageIndex = 362; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockUnlockCodec.RequestParameters parameters = FencedLockUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3241,7 +3195,7 @@ public void test_FencedLockUnlockCodec_decodeRequest() { @Test public void test_FencedLockUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 369; + int fileClientMessageIndex = 363; ClientMessage encoded = FencedLockUnlockCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3249,7 +3203,7 @@ public void test_FencedLockUnlockCodec_encodeResponse() { @Test public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { - int fileClientMessageIndex = 370; + int fileClientMessageIndex = 364; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockGetLockOwnershipCodec.RequestParameters parameters = FencedLockGetLockOwnershipCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3258,7 +3212,7 @@ public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { @Test public void test_FencedLockGetLockOwnershipCodec_encodeResponse() { - int fileClientMessageIndex = 371; + int fileClientMessageIndex = 365; ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeResponse(aLong, anInt, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3266,14 +3220,14 @@ public void test_FencedLockGetLockOwnershipCodec_encodeResponse() { @Test public void test_ExecutorServiceShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 372; + int fileClientMessageIndex = 366; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ExecutorServiceShutdownCodec.decodeRequest(fromFile))); } @Test public void test_ExecutorServiceShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 373; + int fileClientMessageIndex = 367; ClientMessage encoded = ExecutorServiceShutdownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3281,14 +3235,14 @@ public void test_ExecutorServiceShutdownCodec_encodeResponse() { @Test public void test_ExecutorServiceIsShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 374; + int fileClientMessageIndex = 368; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ExecutorServiceIsShutdownCodec.decodeRequest(fromFile))); } @Test public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 375; + int fileClientMessageIndex = 369; ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3296,7 +3250,7 @@ public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { @Test public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 376; + int fileClientMessageIndex = 370; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceCancelOnPartitionCodec.RequestParameters parameters = ExecutorServiceCancelOnPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.uuid)); @@ -3305,7 +3259,7 @@ public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { @Test public void test_ExecutorServiceCancelOnPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 377; + int fileClientMessageIndex = 371; ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3313,7 +3267,7 @@ public void test_ExecutorServiceCancelOnPartitionCodec_encodeResponse() { @Test public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { - int fileClientMessageIndex = 378; + int fileClientMessageIndex = 372; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceCancelOnMemberCodec.RequestParameters parameters = ExecutorServiceCancelOnMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.uuid)); @@ -3323,7 +3277,7 @@ public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { @Test public void test_ExecutorServiceCancelOnMemberCodec_encodeResponse() { - int fileClientMessageIndex = 379; + int fileClientMessageIndex = 373; ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3331,7 +3285,7 @@ public void test_ExecutorServiceCancelOnMemberCodec_encodeResponse() { @Test public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 380; + int fileClientMessageIndex = 374; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceSubmitToPartitionCodec.RequestParameters parameters = ExecutorServiceSubmitToPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3341,7 +3295,7 @@ public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { @Test public void test_ExecutorServiceSubmitToPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 381; + int fileClientMessageIndex = 375; ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3349,7 +3303,7 @@ public void test_ExecutorServiceSubmitToPartitionCodec_encodeResponse() { @Test public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { - int fileClientMessageIndex = 382; + int fileClientMessageIndex = 376; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceSubmitToMemberCodec.RequestParameters parameters = ExecutorServiceSubmitToMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3360,7 +3314,7 @@ public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { @Test public void test_ExecutorServiceSubmitToMemberCodec_encodeResponse() { - int fileClientMessageIndex = 383; + int fileClientMessageIndex = 377; ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3368,7 +3322,7 @@ public void test_ExecutorServiceSubmitToMemberCodec_encodeResponse() { @Test public void test_AtomicLongApplyCodec_decodeRequest() { - int fileClientMessageIndex = 384; + int fileClientMessageIndex = 378; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongApplyCodec.RequestParameters parameters = AtomicLongApplyCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3378,7 +3332,7 @@ public void test_AtomicLongApplyCodec_decodeRequest() { @Test public void test_AtomicLongApplyCodec_encodeResponse() { - int fileClientMessageIndex = 385; + int fileClientMessageIndex = 379; ClientMessage encoded = AtomicLongApplyCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3386,7 +3340,7 @@ public void test_AtomicLongApplyCodec_encodeResponse() { @Test public void test_AtomicLongAlterCodec_decodeRequest() { - int fileClientMessageIndex = 386; + int fileClientMessageIndex = 380; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongAlterCodec.RequestParameters parameters = AtomicLongAlterCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3397,7 +3351,7 @@ public void test_AtomicLongAlterCodec_decodeRequest() { @Test public void test_AtomicLongAlterCodec_encodeResponse() { - int fileClientMessageIndex = 387; + int fileClientMessageIndex = 381; ClientMessage encoded = AtomicLongAlterCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3405,7 +3359,7 @@ public void test_AtomicLongAlterCodec_encodeResponse() { @Test public void test_AtomicLongAddAndGetCodec_decodeRequest() { - int fileClientMessageIndex = 388; + int fileClientMessageIndex = 382; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongAddAndGetCodec.RequestParameters parameters = AtomicLongAddAndGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3415,7 +3369,7 @@ public void test_AtomicLongAddAndGetCodec_decodeRequest() { @Test public void test_AtomicLongAddAndGetCodec_encodeResponse() { - int fileClientMessageIndex = 389; + int fileClientMessageIndex = 383; ClientMessage encoded = AtomicLongAddAndGetCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3423,7 +3377,7 @@ public void test_AtomicLongAddAndGetCodec_encodeResponse() { @Test public void test_AtomicLongCompareAndSetCodec_decodeRequest() { - int fileClientMessageIndex = 390; + int fileClientMessageIndex = 384; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongCompareAndSetCodec.RequestParameters parameters = AtomicLongCompareAndSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3434,7 +3388,7 @@ public void test_AtomicLongCompareAndSetCodec_decodeRequest() { @Test public void test_AtomicLongCompareAndSetCodec_encodeResponse() { - int fileClientMessageIndex = 391; + int fileClientMessageIndex = 385; ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3442,7 +3396,7 @@ public void test_AtomicLongCompareAndSetCodec_encodeResponse() { @Test public void test_AtomicLongGetCodec_decodeRequest() { - int fileClientMessageIndex = 392; + int fileClientMessageIndex = 386; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongGetCodec.RequestParameters parameters = AtomicLongGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3451,7 +3405,7 @@ public void test_AtomicLongGetCodec_decodeRequest() { @Test public void test_AtomicLongGetCodec_encodeResponse() { - int fileClientMessageIndex = 393; + int fileClientMessageIndex = 387; ClientMessage encoded = AtomicLongGetCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3459,7 +3413,7 @@ public void test_AtomicLongGetCodec_encodeResponse() { @Test public void test_AtomicLongGetAndAddCodec_decodeRequest() { - int fileClientMessageIndex = 394; + int fileClientMessageIndex = 388; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongGetAndAddCodec.RequestParameters parameters = AtomicLongGetAndAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3469,7 +3423,7 @@ public void test_AtomicLongGetAndAddCodec_decodeRequest() { @Test public void test_AtomicLongGetAndAddCodec_encodeResponse() { - int fileClientMessageIndex = 395; + int fileClientMessageIndex = 389; ClientMessage encoded = AtomicLongGetAndAddCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3477,7 +3431,7 @@ public void test_AtomicLongGetAndAddCodec_encodeResponse() { @Test public void test_AtomicLongGetAndSetCodec_decodeRequest() { - int fileClientMessageIndex = 396; + int fileClientMessageIndex = 390; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongGetAndSetCodec.RequestParameters parameters = AtomicLongGetAndSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3487,7 +3441,7 @@ public void test_AtomicLongGetAndSetCodec_decodeRequest() { @Test public void test_AtomicLongGetAndSetCodec_encodeResponse() { - int fileClientMessageIndex = 397; + int fileClientMessageIndex = 391; ClientMessage encoded = AtomicLongGetAndSetCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3495,7 +3449,7 @@ public void test_AtomicLongGetAndSetCodec_encodeResponse() { @Test public void test_AtomicRefApplyCodec_decodeRequest() { - int fileClientMessageIndex = 398; + int fileClientMessageIndex = 392; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefApplyCodec.RequestParameters parameters = AtomicRefApplyCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3507,7 +3461,7 @@ public void test_AtomicRefApplyCodec_decodeRequest() { @Test public void test_AtomicRefApplyCodec_encodeResponse() { - int fileClientMessageIndex = 399; + int fileClientMessageIndex = 393; ClientMessage encoded = AtomicRefApplyCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3515,7 +3469,7 @@ public void test_AtomicRefApplyCodec_encodeResponse() { @Test public void test_AtomicRefCompareAndSetCodec_decodeRequest() { - int fileClientMessageIndex = 400; + int fileClientMessageIndex = 394; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefCompareAndSetCodec.RequestParameters parameters = AtomicRefCompareAndSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3526,7 +3480,7 @@ public void test_AtomicRefCompareAndSetCodec_decodeRequest() { @Test public void test_AtomicRefCompareAndSetCodec_encodeResponse() { - int fileClientMessageIndex = 401; + int fileClientMessageIndex = 395; ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3534,7 +3488,7 @@ public void test_AtomicRefCompareAndSetCodec_encodeResponse() { @Test public void test_AtomicRefContainsCodec_decodeRequest() { - int fileClientMessageIndex = 402; + int fileClientMessageIndex = 396; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefContainsCodec.RequestParameters parameters = AtomicRefContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3544,7 +3498,7 @@ public void test_AtomicRefContainsCodec_decodeRequest() { @Test public void test_AtomicRefContainsCodec_encodeResponse() { - int fileClientMessageIndex = 403; + int fileClientMessageIndex = 397; ClientMessage encoded = AtomicRefContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3552,7 +3506,7 @@ public void test_AtomicRefContainsCodec_encodeResponse() { @Test public void test_AtomicRefGetCodec_decodeRequest() { - int fileClientMessageIndex = 404; + int fileClientMessageIndex = 398; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefGetCodec.RequestParameters parameters = AtomicRefGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3561,7 +3515,7 @@ public void test_AtomicRefGetCodec_decodeRequest() { @Test public void test_AtomicRefGetCodec_encodeResponse() { - int fileClientMessageIndex = 405; + int fileClientMessageIndex = 399; ClientMessage encoded = AtomicRefGetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3569,7 +3523,7 @@ public void test_AtomicRefGetCodec_encodeResponse() { @Test public void test_AtomicRefSetCodec_decodeRequest() { - int fileClientMessageIndex = 406; + int fileClientMessageIndex = 400; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefSetCodec.RequestParameters parameters = AtomicRefSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3580,7 +3534,7 @@ public void test_AtomicRefSetCodec_decodeRequest() { @Test public void test_AtomicRefSetCodec_encodeResponse() { - int fileClientMessageIndex = 407; + int fileClientMessageIndex = 401; ClientMessage encoded = AtomicRefSetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3588,7 +3542,7 @@ public void test_AtomicRefSetCodec_encodeResponse() { @Test public void test_CountDownLatchTrySetCountCodec_decodeRequest() { - int fileClientMessageIndex = 408; + int fileClientMessageIndex = 402; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchTrySetCountCodec.RequestParameters parameters = CountDownLatchTrySetCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3598,7 +3552,7 @@ public void test_CountDownLatchTrySetCountCodec_decodeRequest() { @Test public void test_CountDownLatchTrySetCountCodec_encodeResponse() { - int fileClientMessageIndex = 409; + int fileClientMessageIndex = 403; ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3606,7 +3560,7 @@ public void test_CountDownLatchTrySetCountCodec_encodeResponse() { @Test public void test_CountDownLatchAwaitCodec_decodeRequest() { - int fileClientMessageIndex = 410; + int fileClientMessageIndex = 404; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchAwaitCodec.RequestParameters parameters = CountDownLatchAwaitCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3617,7 +3571,7 @@ public void test_CountDownLatchAwaitCodec_decodeRequest() { @Test public void test_CountDownLatchAwaitCodec_encodeResponse() { - int fileClientMessageIndex = 411; + int fileClientMessageIndex = 405; ClientMessage encoded = CountDownLatchAwaitCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3625,7 +3579,7 @@ public void test_CountDownLatchAwaitCodec_encodeResponse() { @Test public void test_CountDownLatchCountDownCodec_decodeRequest() { - int fileClientMessageIndex = 412; + int fileClientMessageIndex = 406; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchCountDownCodec.RequestParameters parameters = CountDownLatchCountDownCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3636,7 +3590,7 @@ public void test_CountDownLatchCountDownCodec_decodeRequest() { @Test public void test_CountDownLatchCountDownCodec_encodeResponse() { - int fileClientMessageIndex = 413; + int fileClientMessageIndex = 407; ClientMessage encoded = CountDownLatchCountDownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3644,7 +3598,7 @@ public void test_CountDownLatchCountDownCodec_encodeResponse() { @Test public void test_CountDownLatchGetCountCodec_decodeRequest() { - int fileClientMessageIndex = 414; + int fileClientMessageIndex = 408; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchGetCountCodec.RequestParameters parameters = CountDownLatchGetCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3653,7 +3607,7 @@ public void test_CountDownLatchGetCountCodec_decodeRequest() { @Test public void test_CountDownLatchGetCountCodec_encodeResponse() { - int fileClientMessageIndex = 415; + int fileClientMessageIndex = 409; ClientMessage encoded = CountDownLatchGetCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3661,7 +3615,7 @@ public void test_CountDownLatchGetCountCodec_encodeResponse() { @Test public void test_CountDownLatchGetRoundCodec_decodeRequest() { - int fileClientMessageIndex = 416; + int fileClientMessageIndex = 410; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchGetRoundCodec.RequestParameters parameters = CountDownLatchGetRoundCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3670,7 +3624,7 @@ public void test_CountDownLatchGetRoundCodec_decodeRequest() { @Test public void test_CountDownLatchGetRoundCodec_encodeResponse() { - int fileClientMessageIndex = 417; + int fileClientMessageIndex = 411; ClientMessage encoded = CountDownLatchGetRoundCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3678,7 +3632,7 @@ public void test_CountDownLatchGetRoundCodec_encodeResponse() { @Test public void test_SemaphoreInitCodec_decodeRequest() { - int fileClientMessageIndex = 418; + int fileClientMessageIndex = 412; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreInitCodec.RequestParameters parameters = SemaphoreInitCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3688,7 +3642,7 @@ public void test_SemaphoreInitCodec_decodeRequest() { @Test public void test_SemaphoreInitCodec_encodeResponse() { - int fileClientMessageIndex = 419; + int fileClientMessageIndex = 413; ClientMessage encoded = SemaphoreInitCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3696,7 +3650,7 @@ public void test_SemaphoreInitCodec_encodeResponse() { @Test public void test_SemaphoreAcquireCodec_decodeRequest() { - int fileClientMessageIndex = 420; + int fileClientMessageIndex = 414; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreAcquireCodec.RequestParameters parameters = SemaphoreAcquireCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3710,7 +3664,7 @@ public void test_SemaphoreAcquireCodec_decodeRequest() { @Test public void test_SemaphoreAcquireCodec_encodeResponse() { - int fileClientMessageIndex = 421; + int fileClientMessageIndex = 415; ClientMessage encoded = SemaphoreAcquireCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3718,7 +3672,7 @@ public void test_SemaphoreAcquireCodec_encodeResponse() { @Test public void test_SemaphoreReleaseCodec_decodeRequest() { - int fileClientMessageIndex = 422; + int fileClientMessageIndex = 416; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreReleaseCodec.RequestParameters parameters = SemaphoreReleaseCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3731,7 +3685,7 @@ public void test_SemaphoreReleaseCodec_decodeRequest() { @Test public void test_SemaphoreReleaseCodec_encodeResponse() { - int fileClientMessageIndex = 423; + int fileClientMessageIndex = 417; ClientMessage encoded = SemaphoreReleaseCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3739,7 +3693,7 @@ public void test_SemaphoreReleaseCodec_encodeResponse() { @Test public void test_SemaphoreDrainCodec_decodeRequest() { - int fileClientMessageIndex = 424; + int fileClientMessageIndex = 418; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreDrainCodec.RequestParameters parameters = SemaphoreDrainCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3751,7 +3705,7 @@ public void test_SemaphoreDrainCodec_decodeRequest() { @Test public void test_SemaphoreDrainCodec_encodeResponse() { - int fileClientMessageIndex = 425; + int fileClientMessageIndex = 419; ClientMessage encoded = SemaphoreDrainCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3759,7 +3713,7 @@ public void test_SemaphoreDrainCodec_encodeResponse() { @Test public void test_SemaphoreChangeCodec_decodeRequest() { - int fileClientMessageIndex = 426; + int fileClientMessageIndex = 420; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreChangeCodec.RequestParameters parameters = SemaphoreChangeCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3772,7 +3726,7 @@ public void test_SemaphoreChangeCodec_decodeRequest() { @Test public void test_SemaphoreChangeCodec_encodeResponse() { - int fileClientMessageIndex = 427; + int fileClientMessageIndex = 421; ClientMessage encoded = SemaphoreChangeCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3780,7 +3734,7 @@ public void test_SemaphoreChangeCodec_encodeResponse() { @Test public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { - int fileClientMessageIndex = 428; + int fileClientMessageIndex = 422; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreAvailablePermitsCodec.RequestParameters parameters = SemaphoreAvailablePermitsCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3789,7 +3743,7 @@ public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { @Test public void test_SemaphoreAvailablePermitsCodec_encodeResponse() { - int fileClientMessageIndex = 429; + int fileClientMessageIndex = 423; ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3797,14 +3751,14 @@ public void test_SemaphoreAvailablePermitsCodec_encodeResponse() { @Test public void test_SemaphoreGetSemaphoreTypeCodec_decodeRequest() { - int fileClientMessageIndex = 430; + int fileClientMessageIndex = 424; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SemaphoreGetSemaphoreTypeCodec.decodeRequest(fromFile))); } @Test public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { - int fileClientMessageIndex = 431; + int fileClientMessageIndex = 425; ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3812,7 +3766,7 @@ public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { @Test public void test_ReplicatedMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 432; + int fileClientMessageIndex = 426; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapPutCodec.RequestParameters parameters = ReplicatedMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3823,7 +3777,7 @@ public void test_ReplicatedMapPutCodec_decodeRequest() { @Test public void test_ReplicatedMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 433; + int fileClientMessageIndex = 427; ClientMessage encoded = ReplicatedMapPutCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3831,14 +3785,14 @@ public void test_ReplicatedMapPutCodec_encodeResponse() { @Test public void test_ReplicatedMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 434; + int fileClientMessageIndex = 428; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapSizeCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 435; + int fileClientMessageIndex = 429; ClientMessage encoded = ReplicatedMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3846,14 +3800,14 @@ public void test_ReplicatedMapSizeCodec_encodeResponse() { @Test public void test_ReplicatedMapIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 436; + int fileClientMessageIndex = 430; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 437; + int fileClientMessageIndex = 431; ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3861,7 +3815,7 @@ public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { @Test public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 438; + int fileClientMessageIndex = 432; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapContainsKeyCodec.RequestParameters parameters = ReplicatedMapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3870,7 +3824,7 @@ public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { @Test public void test_ReplicatedMapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 439; + int fileClientMessageIndex = 433; ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3878,7 +3832,7 @@ public void test_ReplicatedMapContainsKeyCodec_encodeResponse() { @Test public void test_ReplicatedMapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 440; + int fileClientMessageIndex = 434; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapContainsValueCodec.RequestParameters parameters = ReplicatedMapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3887,7 +3841,7 @@ public void test_ReplicatedMapContainsValueCodec_decodeRequest() { @Test public void test_ReplicatedMapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 441; + int fileClientMessageIndex = 435; ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3895,7 +3849,7 @@ public void test_ReplicatedMapContainsValueCodec_encodeResponse() { @Test public void test_ReplicatedMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 442; + int fileClientMessageIndex = 436; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapGetCodec.RequestParameters parameters = ReplicatedMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3904,7 +3858,7 @@ public void test_ReplicatedMapGetCodec_decodeRequest() { @Test public void test_ReplicatedMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 443; + int fileClientMessageIndex = 437; ClientMessage encoded = ReplicatedMapGetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3912,7 +3866,7 @@ public void test_ReplicatedMapGetCodec_encodeResponse() { @Test public void test_ReplicatedMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 444; + int fileClientMessageIndex = 438; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapRemoveCodec.RequestParameters parameters = ReplicatedMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3921,7 +3875,7 @@ public void test_ReplicatedMapRemoveCodec_decodeRequest() { @Test public void test_ReplicatedMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 445; + int fileClientMessageIndex = 439; ClientMessage encoded = ReplicatedMapRemoveCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3929,7 +3883,7 @@ public void test_ReplicatedMapRemoveCodec_encodeResponse() { @Test public void test_ReplicatedMapPutAllCodec_decodeRequest() { - int fileClientMessageIndex = 446; + int fileClientMessageIndex = 440; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapPutAllCodec.RequestParameters parameters = ReplicatedMapPutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3938,7 +3892,7 @@ public void test_ReplicatedMapPutAllCodec_decodeRequest() { @Test public void test_ReplicatedMapPutAllCodec_encodeResponse() { - int fileClientMessageIndex = 447; + int fileClientMessageIndex = 441; ClientMessage encoded = ReplicatedMapPutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3946,14 +3900,14 @@ public void test_ReplicatedMapPutAllCodec_encodeResponse() { @Test public void test_ReplicatedMapClearCodec_decodeRequest() { - int fileClientMessageIndex = 448; + int fileClientMessageIndex = 442; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapClearCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapClearCodec_encodeResponse() { - int fileClientMessageIndex = 449; + int fileClientMessageIndex = 443; ClientMessage encoded = ReplicatedMapClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3961,7 +3915,7 @@ public void test_ReplicatedMapClearCodec_encodeResponse() { @Test public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 450; + int fileClientMessageIndex = 444; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3972,7 +3926,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequ @Test public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 451; + int fileClientMessageIndex = 445; ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3980,7 +3934,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeResp @Test public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 452; + int fileClientMessageIndex = 446; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -3988,7 +3942,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntr @Test public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 453; + int fileClientMessageIndex = 447; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3998,7 +3952,7 @@ public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeRequest() @Test public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 454; + int fileClientMessageIndex = 448; ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4006,7 +3960,7 @@ public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeResponse( @Test public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 455; + int fileClientMessageIndex = 449; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4014,7 +3968,7 @@ public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEven @Test public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 456; + int fileClientMessageIndex = 450; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerToKeyCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4024,7 +3978,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeRequest() { @Test public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 457; + int fileClientMessageIndex = 451; ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4032,7 +3986,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeResponse() { @Test public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { - int fileClientMessageIndex = 458; + int fileClientMessageIndex = 452; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4040,7 +3994,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { @Test public void test_ReplicatedMapAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 459; + int fileClientMessageIndex = 453; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4049,7 +4003,7 @@ public void test_ReplicatedMapAddEntryListenerCodec_decodeRequest() { @Test public void test_ReplicatedMapAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 460; + int fileClientMessageIndex = 454; ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4057,7 +4011,7 @@ public void test_ReplicatedMapAddEntryListenerCodec_encodeResponse() { @Test public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 461; + int fileClientMessageIndex = 455; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4065,7 +4019,7 @@ public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { @Test public void test_ReplicatedMapRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 462; + int fileClientMessageIndex = 456; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapRemoveEntryListenerCodec.RequestParameters parameters = ReplicatedMapRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4074,7 +4028,7 @@ public void test_ReplicatedMapRemoveEntryListenerCodec_decodeRequest() { @Test public void test_ReplicatedMapRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 463; + int fileClientMessageIndex = 457; ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4082,14 +4036,14 @@ public void test_ReplicatedMapRemoveEntryListenerCodec_encodeResponse() { @Test public void test_ReplicatedMapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 464; + int fileClientMessageIndex = 458; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapKeySetCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 465; + int fileClientMessageIndex = 459; ClientMessage encoded = ReplicatedMapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4097,14 +4051,14 @@ public void test_ReplicatedMapKeySetCodec_encodeResponse() { @Test public void test_ReplicatedMapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 466; + int fileClientMessageIndex = 460; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapValuesCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 467; + int fileClientMessageIndex = 461; ClientMessage encoded = ReplicatedMapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4112,14 +4066,14 @@ public void test_ReplicatedMapValuesCodec_encodeResponse() { @Test public void test_ReplicatedMapEntrySetCodec_decodeRequest() { - int fileClientMessageIndex = 468; + int fileClientMessageIndex = 462; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapEntrySetCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapEntrySetCodec_encodeResponse() { - int fileClientMessageIndex = 469; + int fileClientMessageIndex = 463; ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4127,7 +4081,7 @@ public void test_ReplicatedMapEntrySetCodec_encodeResponse() { @Test public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 470; + int fileClientMessageIndex = 464; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddNearCacheEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddNearCacheEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4137,7 +4091,7 @@ public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { @Test public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 471; + int fileClientMessageIndex = 465; ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4145,7 +4099,7 @@ public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeResponse() { @Test public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 472; + int fileClientMessageIndex = 466; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeEntryEvent(null, null, null, null, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4153,7 +4107,7 @@ public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() @Test public void test_TransactionalMapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 473; + int fileClientMessageIndex = 467; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapContainsKeyCodec.RequestParameters parameters = TransactionalMapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4164,7 +4118,7 @@ public void test_TransactionalMapContainsKeyCodec_decodeRequest() { @Test public void test_TransactionalMapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 474; + int fileClientMessageIndex = 468; ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4172,7 +4126,7 @@ public void test_TransactionalMapContainsKeyCodec_encodeResponse() { @Test public void test_TransactionalMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 475; + int fileClientMessageIndex = 469; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapGetCodec.RequestParameters parameters = TransactionalMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4183,7 +4137,7 @@ public void test_TransactionalMapGetCodec_decodeRequest() { @Test public void test_TransactionalMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 476; + int fileClientMessageIndex = 470; ClientMessage encoded = TransactionalMapGetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4191,7 +4145,7 @@ public void test_TransactionalMapGetCodec_encodeResponse() { @Test public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { - int fileClientMessageIndex = 477; + int fileClientMessageIndex = 471; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapGetForUpdateCodec.RequestParameters parameters = TransactionalMapGetForUpdateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4202,7 +4156,7 @@ public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { @Test public void test_TransactionalMapGetForUpdateCodec_encodeResponse() { - int fileClientMessageIndex = 478; + int fileClientMessageIndex = 472; ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4210,7 +4164,7 @@ public void test_TransactionalMapGetForUpdateCodec_encodeResponse() { @Test public void test_TransactionalMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 479; + int fileClientMessageIndex = 473; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapSizeCodec.RequestParameters parameters = TransactionalMapSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4220,7 +4174,7 @@ public void test_TransactionalMapSizeCodec_decodeRequest() { @Test public void test_TransactionalMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 480; + int fileClientMessageIndex = 474; ClientMessage encoded = TransactionalMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4228,7 +4182,7 @@ public void test_TransactionalMapSizeCodec_encodeResponse() { @Test public void test_TransactionalMapIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 481; + int fileClientMessageIndex = 475; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapIsEmptyCodec.RequestParameters parameters = TransactionalMapIsEmptyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4238,7 +4192,7 @@ public void test_TransactionalMapIsEmptyCodec_decodeRequest() { @Test public void test_TransactionalMapIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 482; + int fileClientMessageIndex = 476; ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4246,7 +4200,7 @@ public void test_TransactionalMapIsEmptyCodec_encodeResponse() { @Test public void test_TransactionalMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 483; + int fileClientMessageIndex = 477; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapPutCodec.RequestParameters parameters = TransactionalMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4259,7 +4213,7 @@ public void test_TransactionalMapPutCodec_decodeRequest() { @Test public void test_TransactionalMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 484; + int fileClientMessageIndex = 478; ClientMessage encoded = TransactionalMapPutCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4267,7 +4221,7 @@ public void test_TransactionalMapPutCodec_encodeResponse() { @Test public void test_TransactionalMapSetCodec_decodeRequest() { - int fileClientMessageIndex = 485; + int fileClientMessageIndex = 479; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapSetCodec.RequestParameters parameters = TransactionalMapSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4279,7 +4233,7 @@ public void test_TransactionalMapSetCodec_decodeRequest() { @Test public void test_TransactionalMapSetCodec_encodeResponse() { - int fileClientMessageIndex = 486; + int fileClientMessageIndex = 480; ClientMessage encoded = TransactionalMapSetCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4287,7 +4241,7 @@ public void test_TransactionalMapSetCodec_encodeResponse() { @Test public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { - int fileClientMessageIndex = 487; + int fileClientMessageIndex = 481; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapPutIfAbsentCodec.RequestParameters parameters = TransactionalMapPutIfAbsentCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4299,7 +4253,7 @@ public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { @Test public void test_TransactionalMapPutIfAbsentCodec_encodeResponse() { - int fileClientMessageIndex = 488; + int fileClientMessageIndex = 482; ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4307,7 +4261,7 @@ public void test_TransactionalMapPutIfAbsentCodec_encodeResponse() { @Test public void test_TransactionalMapReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 489; + int fileClientMessageIndex = 483; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapReplaceCodec.RequestParameters parameters = TransactionalMapReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4319,7 +4273,7 @@ public void test_TransactionalMapReplaceCodec_decodeRequest() { @Test public void test_TransactionalMapReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 490; + int fileClientMessageIndex = 484; ClientMessage encoded = TransactionalMapReplaceCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4327,7 +4281,7 @@ public void test_TransactionalMapReplaceCodec_encodeResponse() { @Test public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 491; + int fileClientMessageIndex = 485; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapReplaceIfSameCodec.RequestParameters parameters = TransactionalMapReplaceIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4340,7 +4294,7 @@ public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { @Test public void test_TransactionalMapReplaceIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 492; + int fileClientMessageIndex = 486; ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4348,7 +4302,7 @@ public void test_TransactionalMapReplaceIfSameCodec_encodeResponse() { @Test public void test_TransactionalMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 493; + int fileClientMessageIndex = 487; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapRemoveCodec.RequestParameters parameters = TransactionalMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4359,7 +4313,7 @@ public void test_TransactionalMapRemoveCodec_decodeRequest() { @Test public void test_TransactionalMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 494; + int fileClientMessageIndex = 488; ClientMessage encoded = TransactionalMapRemoveCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4367,7 +4321,7 @@ public void test_TransactionalMapRemoveCodec_encodeResponse() { @Test public void test_TransactionalMapDeleteCodec_decodeRequest() { - int fileClientMessageIndex = 495; + int fileClientMessageIndex = 489; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapDeleteCodec.RequestParameters parameters = TransactionalMapDeleteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4378,7 +4332,7 @@ public void test_TransactionalMapDeleteCodec_decodeRequest() { @Test public void test_TransactionalMapDeleteCodec_encodeResponse() { - int fileClientMessageIndex = 496; + int fileClientMessageIndex = 490; ClientMessage encoded = TransactionalMapDeleteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4386,7 +4340,7 @@ public void test_TransactionalMapDeleteCodec_encodeResponse() { @Test public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 497; + int fileClientMessageIndex = 491; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapRemoveIfSameCodec.RequestParameters parameters = TransactionalMapRemoveIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4398,7 +4352,7 @@ public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { @Test public void test_TransactionalMapRemoveIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 498; + int fileClientMessageIndex = 492; ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4406,7 +4360,7 @@ public void test_TransactionalMapRemoveIfSameCodec_encodeResponse() { @Test public void test_TransactionalMapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 499; + int fileClientMessageIndex = 493; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapKeySetCodec.RequestParameters parameters = TransactionalMapKeySetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4416,7 +4370,7 @@ public void test_TransactionalMapKeySetCodec_decodeRequest() { @Test public void test_TransactionalMapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 500; + int fileClientMessageIndex = 494; ClientMessage encoded = TransactionalMapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4424,7 +4378,7 @@ public void test_TransactionalMapKeySetCodec_encodeResponse() { @Test public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 501; + int fileClientMessageIndex = 495; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapKeySetWithPredicateCodec.RequestParameters parameters = TransactionalMapKeySetWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4435,7 +4389,7 @@ public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { @Test public void test_TransactionalMapKeySetWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 502; + int fileClientMessageIndex = 496; ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4443,7 +4397,7 @@ public void test_TransactionalMapKeySetWithPredicateCodec_encodeResponse() { @Test public void test_TransactionalMapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 503; + int fileClientMessageIndex = 497; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapValuesCodec.RequestParameters parameters = TransactionalMapValuesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4453,7 +4407,7 @@ public void test_TransactionalMapValuesCodec_decodeRequest() { @Test public void test_TransactionalMapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 504; + int fileClientMessageIndex = 498; ClientMessage encoded = TransactionalMapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4461,7 +4415,7 @@ public void test_TransactionalMapValuesCodec_encodeResponse() { @Test public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 505; + int fileClientMessageIndex = 499; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapValuesWithPredicateCodec.RequestParameters parameters = TransactionalMapValuesWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4472,7 +4426,7 @@ public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { @Test public void test_TransactionalMapValuesWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 506; + int fileClientMessageIndex = 500; ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4480,7 +4434,7 @@ public void test_TransactionalMapValuesWithPredicateCodec_encodeResponse() { @Test public void test_TransactionalMapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 507; + int fileClientMessageIndex = 501; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapContainsValueCodec.RequestParameters parameters = TransactionalMapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4491,7 +4445,7 @@ public void test_TransactionalMapContainsValueCodec_decodeRequest() { @Test public void test_TransactionalMapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 508; + int fileClientMessageIndex = 502; ClientMessage encoded = TransactionalMapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4499,7 +4453,7 @@ public void test_TransactionalMapContainsValueCodec_encodeResponse() { @Test public void test_TransactionalMultiMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 509; + int fileClientMessageIndex = 503; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapPutCodec.RequestParameters parameters = TransactionalMultiMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4511,7 +4465,7 @@ public void test_TransactionalMultiMapPutCodec_decodeRequest() { @Test public void test_TransactionalMultiMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 510; + int fileClientMessageIndex = 504; ClientMessage encoded = TransactionalMultiMapPutCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4519,7 +4473,7 @@ public void test_TransactionalMultiMapPutCodec_encodeResponse() { @Test public void test_TransactionalMultiMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 511; + int fileClientMessageIndex = 505; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapGetCodec.RequestParameters parameters = TransactionalMultiMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4530,7 +4484,7 @@ public void test_TransactionalMultiMapGetCodec_decodeRequest() { @Test public void test_TransactionalMultiMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 512; + int fileClientMessageIndex = 506; ClientMessage encoded = TransactionalMultiMapGetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4538,7 +4492,7 @@ public void test_TransactionalMultiMapGetCodec_encodeResponse() { @Test public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 513; + int fileClientMessageIndex = 507; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapRemoveCodec.RequestParameters parameters = TransactionalMultiMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4549,7 +4503,7 @@ public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { @Test public void test_TransactionalMultiMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 514; + int fileClientMessageIndex = 508; ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4557,7 +4511,7 @@ public void test_TransactionalMultiMapRemoveCodec_encodeResponse() { @Test public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { - int fileClientMessageIndex = 515; + int fileClientMessageIndex = 509; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapRemoveEntryCodec.RequestParameters parameters = TransactionalMultiMapRemoveEntryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4569,7 +4523,7 @@ public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { @Test public void test_TransactionalMultiMapRemoveEntryCodec_encodeResponse() { - int fileClientMessageIndex = 516; + int fileClientMessageIndex = 510; ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4577,7 +4531,7 @@ public void test_TransactionalMultiMapRemoveEntryCodec_encodeResponse() { @Test public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { - int fileClientMessageIndex = 517; + int fileClientMessageIndex = 511; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapValueCountCodec.RequestParameters parameters = TransactionalMultiMapValueCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4588,7 +4542,7 @@ public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { @Test public void test_TransactionalMultiMapValueCountCodec_encodeResponse() { - int fileClientMessageIndex = 518; + int fileClientMessageIndex = 512; ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4596,7 +4550,7 @@ public void test_TransactionalMultiMapValueCountCodec_encodeResponse() { @Test public void test_TransactionalMultiMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 519; + int fileClientMessageIndex = 513; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapSizeCodec.RequestParameters parameters = TransactionalMultiMapSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4606,7 +4560,7 @@ public void test_TransactionalMultiMapSizeCodec_decodeRequest() { @Test public void test_TransactionalMultiMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 520; + int fileClientMessageIndex = 514; ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4614,7 +4568,7 @@ public void test_TransactionalMultiMapSizeCodec_encodeResponse() { @Test public void test_TransactionalSetAddCodec_decodeRequest() { - int fileClientMessageIndex = 521; + int fileClientMessageIndex = 515; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalSetAddCodec.RequestParameters parameters = TransactionalSetAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4625,7 +4579,7 @@ public void test_TransactionalSetAddCodec_decodeRequest() { @Test public void test_TransactionalSetAddCodec_encodeResponse() { - int fileClientMessageIndex = 522; + int fileClientMessageIndex = 516; ClientMessage encoded = TransactionalSetAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4633,7 +4587,7 @@ public void test_TransactionalSetAddCodec_encodeResponse() { @Test public void test_TransactionalSetRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 523; + int fileClientMessageIndex = 517; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalSetRemoveCodec.RequestParameters parameters = TransactionalSetRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4644,7 +4598,7 @@ public void test_TransactionalSetRemoveCodec_decodeRequest() { @Test public void test_TransactionalSetRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 524; + int fileClientMessageIndex = 518; ClientMessage encoded = TransactionalSetRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4652,7 +4606,7 @@ public void test_TransactionalSetRemoveCodec_encodeResponse() { @Test public void test_TransactionalSetSizeCodec_decodeRequest() { - int fileClientMessageIndex = 525; + int fileClientMessageIndex = 519; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalSetSizeCodec.RequestParameters parameters = TransactionalSetSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4662,7 +4616,7 @@ public void test_TransactionalSetSizeCodec_decodeRequest() { @Test public void test_TransactionalSetSizeCodec_encodeResponse() { - int fileClientMessageIndex = 526; + int fileClientMessageIndex = 520; ClientMessage encoded = TransactionalSetSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4670,7 +4624,7 @@ public void test_TransactionalSetSizeCodec_encodeResponse() { @Test public void test_TransactionalListAddCodec_decodeRequest() { - int fileClientMessageIndex = 527; + int fileClientMessageIndex = 521; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalListAddCodec.RequestParameters parameters = TransactionalListAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4681,7 +4635,7 @@ public void test_TransactionalListAddCodec_decodeRequest() { @Test public void test_TransactionalListAddCodec_encodeResponse() { - int fileClientMessageIndex = 528; + int fileClientMessageIndex = 522; ClientMessage encoded = TransactionalListAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4689,7 +4643,7 @@ public void test_TransactionalListAddCodec_encodeResponse() { @Test public void test_TransactionalListRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 529; + int fileClientMessageIndex = 523; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalListRemoveCodec.RequestParameters parameters = TransactionalListRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4700,7 +4654,7 @@ public void test_TransactionalListRemoveCodec_decodeRequest() { @Test public void test_TransactionalListRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 530; + int fileClientMessageIndex = 524; ClientMessage encoded = TransactionalListRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4708,7 +4662,7 @@ public void test_TransactionalListRemoveCodec_encodeResponse() { @Test public void test_TransactionalListSizeCodec_decodeRequest() { - int fileClientMessageIndex = 531; + int fileClientMessageIndex = 525; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalListSizeCodec.RequestParameters parameters = TransactionalListSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4718,7 +4672,7 @@ public void test_TransactionalListSizeCodec_decodeRequest() { @Test public void test_TransactionalListSizeCodec_encodeResponse() { - int fileClientMessageIndex = 532; + int fileClientMessageIndex = 526; ClientMessage encoded = TransactionalListSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4726,7 +4680,7 @@ public void test_TransactionalListSizeCodec_encodeResponse() { @Test public void test_TransactionalQueueOfferCodec_decodeRequest() { - int fileClientMessageIndex = 533; + int fileClientMessageIndex = 527; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueueOfferCodec.RequestParameters parameters = TransactionalQueueOfferCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4738,7 +4692,7 @@ public void test_TransactionalQueueOfferCodec_decodeRequest() { @Test public void test_TransactionalQueueOfferCodec_encodeResponse() { - int fileClientMessageIndex = 534; + int fileClientMessageIndex = 528; ClientMessage encoded = TransactionalQueueOfferCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4746,7 +4700,7 @@ public void test_TransactionalQueueOfferCodec_encodeResponse() { @Test public void test_TransactionalQueueTakeCodec_decodeRequest() { - int fileClientMessageIndex = 535; + int fileClientMessageIndex = 529; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueueTakeCodec.RequestParameters parameters = TransactionalQueueTakeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4756,7 +4710,7 @@ public void test_TransactionalQueueTakeCodec_decodeRequest() { @Test public void test_TransactionalQueueTakeCodec_encodeResponse() { - int fileClientMessageIndex = 536; + int fileClientMessageIndex = 530; ClientMessage encoded = TransactionalQueueTakeCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4764,7 +4718,7 @@ public void test_TransactionalQueueTakeCodec_encodeResponse() { @Test public void test_TransactionalQueuePollCodec_decodeRequest() { - int fileClientMessageIndex = 537; + int fileClientMessageIndex = 531; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueuePollCodec.RequestParameters parameters = TransactionalQueuePollCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4775,7 +4729,7 @@ public void test_TransactionalQueuePollCodec_decodeRequest() { @Test public void test_TransactionalQueuePollCodec_encodeResponse() { - int fileClientMessageIndex = 538; + int fileClientMessageIndex = 532; ClientMessage encoded = TransactionalQueuePollCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4783,7 +4737,7 @@ public void test_TransactionalQueuePollCodec_encodeResponse() { @Test public void test_TransactionalQueuePeekCodec_decodeRequest() { - int fileClientMessageIndex = 539; + int fileClientMessageIndex = 533; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueuePeekCodec.RequestParameters parameters = TransactionalQueuePeekCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4794,7 +4748,7 @@ public void test_TransactionalQueuePeekCodec_decodeRequest() { @Test public void test_TransactionalQueuePeekCodec_encodeResponse() { - int fileClientMessageIndex = 540; + int fileClientMessageIndex = 534; ClientMessage encoded = TransactionalQueuePeekCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4802,7 +4756,7 @@ public void test_TransactionalQueuePeekCodec_encodeResponse() { @Test public void test_TransactionalQueueSizeCodec_decodeRequest() { - int fileClientMessageIndex = 541; + int fileClientMessageIndex = 535; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueueSizeCodec.RequestParameters parameters = TransactionalQueueSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4812,7 +4766,7 @@ public void test_TransactionalQueueSizeCodec_decodeRequest() { @Test public void test_TransactionalQueueSizeCodec_encodeResponse() { - int fileClientMessageIndex = 542; + int fileClientMessageIndex = 536; ClientMessage encoded = TransactionalQueueSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4820,7 +4774,7 @@ public void test_TransactionalQueueSizeCodec_encodeResponse() { @Test public void test_CacheAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 543; + int fileClientMessageIndex = 537; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheAddEntryListenerCodec.RequestParameters parameters = CacheAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4829,7 +4783,7 @@ public void test_CacheAddEntryListenerCodec_decodeRequest() { @Test public void test_CacheAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 544; + int fileClientMessageIndex = 538; ClientMessage encoded = CacheAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4837,7 +4791,7 @@ public void test_CacheAddEntryListenerCodec_encodeResponse() { @Test public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { - int fileClientMessageIndex = 545; + int fileClientMessageIndex = 539; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddEntryListenerCodec.encodeCacheEvent(anInt, aListOfCacheEventData, anInt); compareClientMessages(fromFile, encoded); @@ -4845,14 +4799,14 @@ public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { @Test public void test_CacheClearCodec_decodeRequest() { - int fileClientMessageIndex = 546; + int fileClientMessageIndex = 540; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheClearCodec.decodeRequest(fromFile))); } @Test public void test_CacheClearCodec_encodeResponse() { - int fileClientMessageIndex = 547; + int fileClientMessageIndex = 541; ClientMessage encoded = CacheClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4860,7 +4814,7 @@ public void test_CacheClearCodec_encodeResponse() { @Test public void test_CacheRemoveAllKeysCodec_decodeRequest() { - int fileClientMessageIndex = 548; + int fileClientMessageIndex = 542; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveAllKeysCodec.RequestParameters parameters = CacheRemoveAllKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4870,7 +4824,7 @@ public void test_CacheRemoveAllKeysCodec_decodeRequest() { @Test public void test_CacheRemoveAllKeysCodec_encodeResponse() { - int fileClientMessageIndex = 549; + int fileClientMessageIndex = 543; ClientMessage encoded = CacheRemoveAllKeysCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4878,7 +4832,7 @@ public void test_CacheRemoveAllKeysCodec_encodeResponse() { @Test public void test_CacheRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 550; + int fileClientMessageIndex = 544; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveAllCodec.RequestParameters parameters = CacheRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4887,7 +4841,7 @@ public void test_CacheRemoveAllCodec_decodeRequest() { @Test public void test_CacheRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 551; + int fileClientMessageIndex = 545; ClientMessage encoded = CacheRemoveAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4895,7 +4849,7 @@ public void test_CacheRemoveAllCodec_encodeResponse() { @Test public void test_CacheContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 552; + int fileClientMessageIndex = 546; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheContainsKeyCodec.RequestParameters parameters = CacheContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4904,7 +4858,7 @@ public void test_CacheContainsKeyCodec_decodeRequest() { @Test public void test_CacheContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 553; + int fileClientMessageIndex = 547; ClientMessage encoded = CacheContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4912,7 +4866,7 @@ public void test_CacheContainsKeyCodec_encodeResponse() { @Test public void test_CacheCreateConfigCodec_decodeRequest() { - int fileClientMessageIndex = 554; + int fileClientMessageIndex = 548; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheCreateConfigCodec.RequestParameters parameters = CacheCreateConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aCacheConfigHolder, parameters.cacheConfig)); @@ -4921,7 +4875,7 @@ public void test_CacheCreateConfigCodec_decodeRequest() { @Test public void test_CacheCreateConfigCodec_encodeResponse() { - int fileClientMessageIndex = 555; + int fileClientMessageIndex = 549; ClientMessage encoded = CacheCreateConfigCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4929,14 +4883,14 @@ public void test_CacheCreateConfigCodec_encodeResponse() { @Test public void test_CacheDestroyCodec_decodeRequest() { - int fileClientMessageIndex = 556; + int fileClientMessageIndex = 550; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheDestroyCodec.decodeRequest(fromFile))); } @Test public void test_CacheDestroyCodec_encodeResponse() { - int fileClientMessageIndex = 557; + int fileClientMessageIndex = 551; ClientMessage encoded = CacheDestroyCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4944,7 +4898,7 @@ public void test_CacheDestroyCodec_encodeResponse() { @Test public void test_CacheEntryProcessorCodec_decodeRequest() { - int fileClientMessageIndex = 558; + int fileClientMessageIndex = 552; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheEntryProcessorCodec.RequestParameters parameters = CacheEntryProcessorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4956,7 +4910,7 @@ public void test_CacheEntryProcessorCodec_decodeRequest() { @Test public void test_CacheEntryProcessorCodec_encodeResponse() { - int fileClientMessageIndex = 559; + int fileClientMessageIndex = 553; ClientMessage encoded = CacheEntryProcessorCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4964,7 +4918,7 @@ public void test_CacheEntryProcessorCodec_encodeResponse() { @Test public void test_CacheGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 560; + int fileClientMessageIndex = 554; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetAllCodec.RequestParameters parameters = CacheGetAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4974,7 +4928,7 @@ public void test_CacheGetAllCodec_decodeRequest() { @Test public void test_CacheGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 561; + int fileClientMessageIndex = 555; ClientMessage encoded = CacheGetAllCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4982,7 +4936,7 @@ public void test_CacheGetAllCodec_encodeResponse() { @Test public void test_CacheGetAndRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 562; + int fileClientMessageIndex = 556; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetAndRemoveCodec.RequestParameters parameters = CacheGetAndRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4992,7 +4946,7 @@ public void test_CacheGetAndRemoveCodec_decodeRequest() { @Test public void test_CacheGetAndRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 563; + int fileClientMessageIndex = 557; ClientMessage encoded = CacheGetAndRemoveCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5000,7 +4954,7 @@ public void test_CacheGetAndRemoveCodec_encodeResponse() { @Test public void test_CacheGetAndReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 564; + int fileClientMessageIndex = 558; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetAndReplaceCodec.RequestParameters parameters = CacheGetAndReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5012,7 +4966,7 @@ public void test_CacheGetAndReplaceCodec_decodeRequest() { @Test public void test_CacheGetAndReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 565; + int fileClientMessageIndex = 559; ClientMessage encoded = CacheGetAndReplaceCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5020,7 +4974,7 @@ public void test_CacheGetAndReplaceCodec_encodeResponse() { @Test public void test_CacheGetConfigCodec_decodeRequest() { - int fileClientMessageIndex = 566; + int fileClientMessageIndex = 560; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetConfigCodec.RequestParameters parameters = CacheGetConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5029,7 +4983,7 @@ public void test_CacheGetConfigCodec_decodeRequest() { @Test public void test_CacheGetConfigCodec_encodeResponse() { - int fileClientMessageIndex = 567; + int fileClientMessageIndex = 561; ClientMessage encoded = CacheGetConfigCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5037,7 +4991,7 @@ public void test_CacheGetConfigCodec_encodeResponse() { @Test public void test_CacheGetCodec_decodeRequest() { - int fileClientMessageIndex = 568; + int fileClientMessageIndex = 562; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetCodec.RequestParameters parameters = CacheGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5047,7 +5001,7 @@ public void test_CacheGetCodec_decodeRequest() { @Test public void test_CacheGetCodec_encodeResponse() { - int fileClientMessageIndex = 569; + int fileClientMessageIndex = 563; ClientMessage encoded = CacheGetCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5055,7 +5009,7 @@ public void test_CacheGetCodec_encodeResponse() { @Test public void test_CacheIterateCodec_decodeRequest() { - int fileClientMessageIndex = 570; + int fileClientMessageIndex = 564; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheIterateCodec.RequestParameters parameters = CacheIterateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5065,7 +5019,7 @@ public void test_CacheIterateCodec_decodeRequest() { @Test public void test_CacheIterateCodec_encodeResponse() { - int fileClientMessageIndex = 571; + int fileClientMessageIndex = 565; ClientMessage encoded = CacheIterateCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5073,7 +5027,7 @@ public void test_CacheIterateCodec_encodeResponse() { @Test public void test_CacheListenerRegistrationCodec_decodeRequest() { - int fileClientMessageIndex = 572; + int fileClientMessageIndex = 566; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheListenerRegistrationCodec.RequestParameters parameters = CacheListenerRegistrationCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5084,7 +5038,7 @@ public void test_CacheListenerRegistrationCodec_decodeRequest() { @Test public void test_CacheListenerRegistrationCodec_encodeResponse() { - int fileClientMessageIndex = 573; + int fileClientMessageIndex = 567; ClientMessage encoded = CacheListenerRegistrationCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5092,7 +5046,7 @@ public void test_CacheListenerRegistrationCodec_encodeResponse() { @Test public void test_CacheLoadAllCodec_decodeRequest() { - int fileClientMessageIndex = 574; + int fileClientMessageIndex = 568; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheLoadAllCodec.RequestParameters parameters = CacheLoadAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5102,7 +5056,7 @@ public void test_CacheLoadAllCodec_decodeRequest() { @Test public void test_CacheLoadAllCodec_encodeResponse() { - int fileClientMessageIndex = 575; + int fileClientMessageIndex = 569; ClientMessage encoded = CacheLoadAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5110,7 +5064,7 @@ public void test_CacheLoadAllCodec_encodeResponse() { @Test public void test_CacheManagementConfigCodec_decodeRequest() { - int fileClientMessageIndex = 576; + int fileClientMessageIndex = 570; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheManagementConfigCodec.RequestParameters parameters = CacheManagementConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5121,7 +5075,7 @@ public void test_CacheManagementConfigCodec_decodeRequest() { @Test public void test_CacheManagementConfigCodec_encodeResponse() { - int fileClientMessageIndex = 577; + int fileClientMessageIndex = 571; ClientMessage encoded = CacheManagementConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5129,7 +5083,7 @@ public void test_CacheManagementConfigCodec_encodeResponse() { @Test public void test_CachePutIfAbsentCodec_decodeRequest() { - int fileClientMessageIndex = 578; + int fileClientMessageIndex = 572; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CachePutIfAbsentCodec.RequestParameters parameters = CachePutIfAbsentCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5141,7 +5095,7 @@ public void test_CachePutIfAbsentCodec_decodeRequest() { @Test public void test_CachePutIfAbsentCodec_encodeResponse() { - int fileClientMessageIndex = 579; + int fileClientMessageIndex = 573; ClientMessage encoded = CachePutIfAbsentCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5149,7 +5103,7 @@ public void test_CachePutIfAbsentCodec_encodeResponse() { @Test public void test_CachePutCodec_decodeRequest() { - int fileClientMessageIndex = 580; + int fileClientMessageIndex = 574; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CachePutCodec.RequestParameters parameters = CachePutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5162,7 +5116,7 @@ public void test_CachePutCodec_decodeRequest() { @Test public void test_CachePutCodec_encodeResponse() { - int fileClientMessageIndex = 581; + int fileClientMessageIndex = 575; ClientMessage encoded = CachePutCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5170,7 +5124,7 @@ public void test_CachePutCodec_encodeResponse() { @Test public void test_CacheRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 582; + int fileClientMessageIndex = 576; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveEntryListenerCodec.RequestParameters parameters = CacheRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5179,7 +5133,7 @@ public void test_CacheRemoveEntryListenerCodec_decodeRequest() { @Test public void test_CacheRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 583; + int fileClientMessageIndex = 577; ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5187,7 +5141,7 @@ public void test_CacheRemoveEntryListenerCodec_encodeResponse() { @Test public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { - int fileClientMessageIndex = 584; + int fileClientMessageIndex = 578; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveInvalidationListenerCodec.RequestParameters parameters = CacheRemoveInvalidationListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5196,7 +5150,7 @@ public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { @Test public void test_CacheRemoveInvalidationListenerCodec_encodeResponse() { - int fileClientMessageIndex = 585; + int fileClientMessageIndex = 579; ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5204,7 +5158,7 @@ public void test_CacheRemoveInvalidationListenerCodec_encodeResponse() { @Test public void test_CacheRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 586; + int fileClientMessageIndex = 580; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveCodec.RequestParameters parameters = CacheRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5215,7 +5169,7 @@ public void test_CacheRemoveCodec_decodeRequest() { @Test public void test_CacheRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 587; + int fileClientMessageIndex = 581; ClientMessage encoded = CacheRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5223,7 +5177,7 @@ public void test_CacheRemoveCodec_encodeResponse() { @Test public void test_CacheReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 588; + int fileClientMessageIndex = 582; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheReplaceCodec.RequestParameters parameters = CacheReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5236,7 +5190,7 @@ public void test_CacheReplaceCodec_decodeRequest() { @Test public void test_CacheReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 589; + int fileClientMessageIndex = 583; ClientMessage encoded = CacheReplaceCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5244,14 +5198,14 @@ public void test_CacheReplaceCodec_encodeResponse() { @Test public void test_CacheSizeCodec_decodeRequest() { - int fileClientMessageIndex = 590; + int fileClientMessageIndex = 584; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheSizeCodec.decodeRequest(fromFile))); } @Test public void test_CacheSizeCodec_encodeResponse() { - int fileClientMessageIndex = 591; + int fileClientMessageIndex = 585; ClientMessage encoded = CacheSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5259,7 +5213,7 @@ public void test_CacheSizeCodec_encodeResponse() { @Test public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 592; + int fileClientMessageIndex = 586; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheAddPartitionLostListenerCodec.RequestParameters parameters = CacheAddPartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5268,7 +5222,7 @@ public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { @Test public void test_CacheAddPartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 593; + int fileClientMessageIndex = 587; ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5276,7 +5230,7 @@ public void test_CacheAddPartitionLostListenerCodec_encodeResponse() { @Test public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEvent() { - int fileClientMessageIndex = 594; + int fileClientMessageIndex = 588; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeCachePartitionLostEvent(anInt, aUUID); compareClientMessages(fromFile, encoded); @@ -5284,7 +5238,7 @@ public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEven @Test public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 595; + int fileClientMessageIndex = 589; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemovePartitionLostListenerCodec.RequestParameters parameters = CacheRemovePartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5293,7 +5247,7 @@ public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { @Test public void test_CacheRemovePartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 596; + int fileClientMessageIndex = 590; ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5301,7 +5255,7 @@ public void test_CacheRemovePartitionLostListenerCodec_encodeResponse() { @Test public void test_CachePutAllCodec_decodeRequest() { - int fileClientMessageIndex = 597; + int fileClientMessageIndex = 591; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CachePutAllCodec.RequestParameters parameters = CachePutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5312,7 +5266,7 @@ public void test_CachePutAllCodec_decodeRequest() { @Test public void test_CachePutAllCodec_encodeResponse() { - int fileClientMessageIndex = 598; + int fileClientMessageIndex = 592; ClientMessage encoded = CachePutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5320,7 +5274,7 @@ public void test_CachePutAllCodec_encodeResponse() { @Test public void test_CacheIterateEntriesCodec_decodeRequest() { - int fileClientMessageIndex = 599; + int fileClientMessageIndex = 593; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheIterateEntriesCodec.RequestParameters parameters = CacheIterateEntriesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5330,7 +5284,7 @@ public void test_CacheIterateEntriesCodec_decodeRequest() { @Test public void test_CacheIterateEntriesCodec_encodeResponse() { - int fileClientMessageIndex = 600; + int fileClientMessageIndex = 594; ClientMessage encoded = CacheIterateEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5338,7 +5292,7 @@ public void test_CacheIterateEntriesCodec_encodeResponse() { @Test public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { - int fileClientMessageIndex = 601; + int fileClientMessageIndex = 595; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheAddNearCacheInvalidationListenerCodec.RequestParameters parameters = CacheAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5347,7 +5301,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { @Test public void test_CacheAddNearCacheInvalidationListenerCodec_encodeResponse() { - int fileClientMessageIndex = 602; + int fileClientMessageIndex = 596; ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5355,7 +5309,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_encodeResponse() { @Test public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidationEvent() { - int fileClientMessageIndex = 603; + int fileClientMessageIndex = 597; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheInvalidationEvent(aString, null, null, aUUID, aLong); compareClientMessages(fromFile, encoded); @@ -5363,7 +5317,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidat @Test public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheBatchInvalidationEvent() { - int fileClientMessageIndex = 604; + int fileClientMessageIndex = 598; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheBatchInvalidationEvent(aString, aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); compareClientMessages(fromFile, encoded); @@ -5371,7 +5325,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheBatchInva @Test public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeRequest() { - int fileClientMessageIndex = 605; + int fileClientMessageIndex = 599; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = CacheFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); assertTrue(isEqual(aListOfStrings, parameters.names)); @@ -5380,7 +5334,7 @@ public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeRequest() { @Test public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeResponse() { - int fileClientMessageIndex = 606; + int fileClientMessageIndex = 600; ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5388,14 +5342,14 @@ public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeResponse() { @Test public void test_CacheEventJournalSubscribeCodec_decodeRequest() { - int fileClientMessageIndex = 607; + int fileClientMessageIndex = 601; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheEventJournalSubscribeCodec.decodeRequest(fromFile))); } @Test public void test_CacheEventJournalSubscribeCodec_encodeResponse() { - int fileClientMessageIndex = 608; + int fileClientMessageIndex = 602; ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeResponse(aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5403,7 +5357,7 @@ public void test_CacheEventJournalSubscribeCodec_encodeResponse() { @Test public void test_CacheEventJournalReadCodec_decodeRequest() { - int fileClientMessageIndex = 609; + int fileClientMessageIndex = 603; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheEventJournalReadCodec.RequestParameters parameters = CacheEventJournalReadCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5416,7 +5370,7 @@ public void test_CacheEventJournalReadCodec_decodeRequest() { @Test public void test_CacheEventJournalReadCodec_encodeResponse() { - int fileClientMessageIndex = 610; + int fileClientMessageIndex = 604; ClientMessage encoded = CacheEventJournalReadCodec.encodeResponse(anInt, aListOfData, null, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5424,7 +5378,7 @@ public void test_CacheEventJournalReadCodec_encodeResponse() { @Test public void test_CacheSetExpiryPolicyCodec_decodeRequest() { - int fileClientMessageIndex = 611; + int fileClientMessageIndex = 605; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheSetExpiryPolicyCodec.RequestParameters parameters = CacheSetExpiryPolicyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5434,7 +5388,7 @@ public void test_CacheSetExpiryPolicyCodec_decodeRequest() { @Test public void test_CacheSetExpiryPolicyCodec_encodeResponse() { - int fileClientMessageIndex = 612; + int fileClientMessageIndex = 606; ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5442,14 +5396,14 @@ public void test_CacheSetExpiryPolicyCodec_encodeResponse() { @Test public void test_XATransactionClearRemoteCodec_decodeRequest() { - int fileClientMessageIndex = 613; + int fileClientMessageIndex = 607; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anXid, XATransactionClearRemoteCodec.decodeRequest(fromFile))); } @Test public void test_XATransactionClearRemoteCodec_encodeResponse() { - int fileClientMessageIndex = 614; + int fileClientMessageIndex = 608; ClientMessage encoded = XATransactionClearRemoteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5457,12 +5411,12 @@ public void test_XATransactionClearRemoteCodec_encodeResponse() { @Test public void test_XATransactionCollectTransactionsCodec_decodeRequest() { - int fileClientMessageIndex = 615; + int fileClientMessageIndex = 609; } @Test public void test_XATransactionCollectTransactionsCodec_encodeResponse() { - int fileClientMessageIndex = 616; + int fileClientMessageIndex = 610; ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeResponse(aListOfXids); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5470,7 +5424,7 @@ public void test_XATransactionCollectTransactionsCodec_encodeResponse() { @Test public void test_XATransactionFinalizeCodec_decodeRequest() { - int fileClientMessageIndex = 617; + int fileClientMessageIndex = 611; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); XATransactionFinalizeCodec.RequestParameters parameters = XATransactionFinalizeCodec.decodeRequest(fromFile); assertTrue(isEqual(anXid, parameters.xid)); @@ -5479,7 +5433,7 @@ public void test_XATransactionFinalizeCodec_decodeRequest() { @Test public void test_XATransactionFinalizeCodec_encodeResponse() { - int fileClientMessageIndex = 618; + int fileClientMessageIndex = 612; ClientMessage encoded = XATransactionFinalizeCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5487,7 +5441,7 @@ public void test_XATransactionFinalizeCodec_encodeResponse() { @Test public void test_XATransactionCommitCodec_decodeRequest() { - int fileClientMessageIndex = 619; + int fileClientMessageIndex = 613; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); XATransactionCommitCodec.RequestParameters parameters = XATransactionCommitCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.transactionId)); @@ -5496,7 +5450,7 @@ public void test_XATransactionCommitCodec_decodeRequest() { @Test public void test_XATransactionCommitCodec_encodeResponse() { - int fileClientMessageIndex = 620; + int fileClientMessageIndex = 614; ClientMessage encoded = XATransactionCommitCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5504,7 +5458,7 @@ public void test_XATransactionCommitCodec_encodeResponse() { @Test public void test_XATransactionCreateCodec_decodeRequest() { - int fileClientMessageIndex = 621; + int fileClientMessageIndex = 615; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); XATransactionCreateCodec.RequestParameters parameters = XATransactionCreateCodec.decodeRequest(fromFile); assertTrue(isEqual(anXid, parameters.xid)); @@ -5513,7 +5467,7 @@ public void test_XATransactionCreateCodec_decodeRequest() { @Test public void test_XATransactionCreateCodec_encodeResponse() { - int fileClientMessageIndex = 622; + int fileClientMessageIndex = 616; ClientMessage encoded = XATransactionCreateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5521,14 +5475,14 @@ public void test_XATransactionCreateCodec_encodeResponse() { @Test public void test_XATransactionPrepareCodec_decodeRequest() { - int fileClientMessageIndex = 623; + int fileClientMessageIndex = 617; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, XATransactionPrepareCodec.decodeRequest(fromFile))); } @Test public void test_XATransactionPrepareCodec_encodeResponse() { - int fileClientMessageIndex = 624; + int fileClientMessageIndex = 618; ClientMessage encoded = XATransactionPrepareCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5536,14 +5490,14 @@ public void test_XATransactionPrepareCodec_encodeResponse() { @Test public void test_XATransactionRollbackCodec_decodeRequest() { - int fileClientMessageIndex = 625; + int fileClientMessageIndex = 619; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, XATransactionRollbackCodec.decodeRequest(fromFile))); } @Test public void test_XATransactionRollbackCodec_encodeResponse() { - int fileClientMessageIndex = 626; + int fileClientMessageIndex = 620; ClientMessage encoded = XATransactionRollbackCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5551,7 +5505,7 @@ public void test_XATransactionRollbackCodec_encodeResponse() { @Test public void test_TransactionCommitCodec_decodeRequest() { - int fileClientMessageIndex = 627; + int fileClientMessageIndex = 621; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionCommitCodec.RequestParameters parameters = TransactionCommitCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.transactionId)); @@ -5560,7 +5514,7 @@ public void test_TransactionCommitCodec_decodeRequest() { @Test public void test_TransactionCommitCodec_encodeResponse() { - int fileClientMessageIndex = 628; + int fileClientMessageIndex = 622; ClientMessage encoded = TransactionCommitCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5568,7 +5522,7 @@ public void test_TransactionCommitCodec_encodeResponse() { @Test public void test_TransactionCreateCodec_decodeRequest() { - int fileClientMessageIndex = 629; + int fileClientMessageIndex = 623; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionCreateCodec.RequestParameters parameters = TransactionCreateCodec.decodeRequest(fromFile); assertTrue(isEqual(aLong, parameters.timeout)); @@ -5579,7 +5533,7 @@ public void test_TransactionCreateCodec_decodeRequest() { @Test public void test_TransactionCreateCodec_encodeResponse() { - int fileClientMessageIndex = 630; + int fileClientMessageIndex = 624; ClientMessage encoded = TransactionCreateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5587,7 +5541,7 @@ public void test_TransactionCreateCodec_encodeResponse() { @Test public void test_TransactionRollbackCodec_decodeRequest() { - int fileClientMessageIndex = 631; + int fileClientMessageIndex = 625; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionRollbackCodec.RequestParameters parameters = TransactionRollbackCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.transactionId)); @@ -5596,7 +5550,7 @@ public void test_TransactionRollbackCodec_decodeRequest() { @Test public void test_TransactionRollbackCodec_encodeResponse() { - int fileClientMessageIndex = 632; + int fileClientMessageIndex = 626; ClientMessage encoded = TransactionRollbackCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5604,7 +5558,7 @@ public void test_TransactionRollbackCodec_encodeResponse() { @Test public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { - int fileClientMessageIndex = 633; + int fileClientMessageIndex = 627; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryPublisherCreateWithValueCodec.RequestParameters parameters = ContinuousQueryPublisherCreateWithValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5619,7 +5573,7 @@ public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { @Test public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeResponse() { - int fileClientMessageIndex = 634; + int fileClientMessageIndex = 628; ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5627,7 +5581,7 @@ public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeResponse() { @Test public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { - int fileClientMessageIndex = 635; + int fileClientMessageIndex = 629; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryPublisherCreateCodec.RequestParameters parameters = ContinuousQueryPublisherCreateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5642,7 +5596,7 @@ public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { @Test public void test_ContinuousQueryPublisherCreateCodec_encodeResponse() { - int fileClientMessageIndex = 636; + int fileClientMessageIndex = 630; ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5650,7 +5604,7 @@ public void test_ContinuousQueryPublisherCreateCodec_encodeResponse() { @Test public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { - int fileClientMessageIndex = 637; + int fileClientMessageIndex = 631; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryMadePublishableCodec.RequestParameters parameters = ContinuousQueryMadePublishableCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5659,7 +5613,7 @@ public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { @Test public void test_ContinuousQueryMadePublishableCodec_encodeResponse() { - int fileClientMessageIndex = 638; + int fileClientMessageIndex = 632; ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5667,7 +5621,7 @@ public void test_ContinuousQueryMadePublishableCodec_encodeResponse() { @Test public void test_ContinuousQueryAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 639; + int fileClientMessageIndex = 633; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryAddListenerCodec.RequestParameters parameters = ContinuousQueryAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.listenerName)); @@ -5676,7 +5630,7 @@ public void test_ContinuousQueryAddListenerCodec_decodeRequest() { @Test public void test_ContinuousQueryAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 640; + int fileClientMessageIndex = 634; ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5684,7 +5638,7 @@ public void test_ContinuousQueryAddListenerCodec_encodeResponse() { @Test public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { - int fileClientMessageIndex = 641; + int fileClientMessageIndex = 635; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheSingleEvent(aQueryCacheEventData); compareClientMessages(fromFile, encoded); @@ -5692,7 +5646,7 @@ public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { @Test public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { - int fileClientMessageIndex = 642; + int fileClientMessageIndex = 636; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheBatchEvent(aListOfQueryCacheEventData, aString, anInt); compareClientMessages(fromFile, encoded); @@ -5700,7 +5654,7 @@ public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { @Test public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { - int fileClientMessageIndex = 643; + int fileClientMessageIndex = 637; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQuerySetReadCursorCodec.RequestParameters parameters = ContinuousQuerySetReadCursorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5710,7 +5664,7 @@ public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { @Test public void test_ContinuousQuerySetReadCursorCodec_encodeResponse() { - int fileClientMessageIndex = 644; + int fileClientMessageIndex = 638; ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5718,7 +5672,7 @@ public void test_ContinuousQuerySetReadCursorCodec_encodeResponse() { @Test public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { - int fileClientMessageIndex = 645; + int fileClientMessageIndex = 639; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryDestroyCacheCodec.RequestParameters parameters = ContinuousQueryDestroyCacheCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5727,7 +5681,7 @@ public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { @Test public void test_ContinuousQueryDestroyCacheCodec_encodeResponse() { - int fileClientMessageIndex = 646; + int fileClientMessageIndex = 640; ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5735,14 +5689,14 @@ public void test_ContinuousQueryDestroyCacheCodec_encodeResponse() { @Test public void test_RingbufferSizeCodec_decodeRequest() { - int fileClientMessageIndex = 647; + int fileClientMessageIndex = 641; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferSizeCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferSizeCodec_encodeResponse() { - int fileClientMessageIndex = 648; + int fileClientMessageIndex = 642; ClientMessage encoded = RingbufferSizeCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5750,14 +5704,14 @@ public void test_RingbufferSizeCodec_encodeResponse() { @Test public void test_RingbufferTailSequenceCodec_decodeRequest() { - int fileClientMessageIndex = 649; + int fileClientMessageIndex = 643; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferTailSequenceCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferTailSequenceCodec_encodeResponse() { - int fileClientMessageIndex = 650; + int fileClientMessageIndex = 644; ClientMessage encoded = RingbufferTailSequenceCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5765,14 +5719,14 @@ public void test_RingbufferTailSequenceCodec_encodeResponse() { @Test public void test_RingbufferHeadSequenceCodec_decodeRequest() { - int fileClientMessageIndex = 651; + int fileClientMessageIndex = 645; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferHeadSequenceCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferHeadSequenceCodec_encodeResponse() { - int fileClientMessageIndex = 652; + int fileClientMessageIndex = 646; ClientMessage encoded = RingbufferHeadSequenceCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5780,14 +5734,14 @@ public void test_RingbufferHeadSequenceCodec_encodeResponse() { @Test public void test_RingbufferCapacityCodec_decodeRequest() { - int fileClientMessageIndex = 653; + int fileClientMessageIndex = 647; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferCapacityCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferCapacityCodec_encodeResponse() { - int fileClientMessageIndex = 654; + int fileClientMessageIndex = 648; ClientMessage encoded = RingbufferCapacityCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5795,14 +5749,14 @@ public void test_RingbufferCapacityCodec_encodeResponse() { @Test public void test_RingbufferRemainingCapacityCodec_decodeRequest() { - int fileClientMessageIndex = 655; + int fileClientMessageIndex = 649; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferRemainingCapacityCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferRemainingCapacityCodec_encodeResponse() { - int fileClientMessageIndex = 656; + int fileClientMessageIndex = 650; ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5810,7 +5764,7 @@ public void test_RingbufferRemainingCapacityCodec_encodeResponse() { @Test public void test_RingbufferAddCodec_decodeRequest() { - int fileClientMessageIndex = 657; + int fileClientMessageIndex = 651; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferAddCodec.RequestParameters parameters = RingbufferAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5820,7 +5774,7 @@ public void test_RingbufferAddCodec_decodeRequest() { @Test public void test_RingbufferAddCodec_encodeResponse() { - int fileClientMessageIndex = 658; + int fileClientMessageIndex = 652; ClientMessage encoded = RingbufferAddCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5828,7 +5782,7 @@ public void test_RingbufferAddCodec_encodeResponse() { @Test public void test_RingbufferReadOneCodec_decodeRequest() { - int fileClientMessageIndex = 659; + int fileClientMessageIndex = 653; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferReadOneCodec.RequestParameters parameters = RingbufferReadOneCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5837,7 +5791,7 @@ public void test_RingbufferReadOneCodec_decodeRequest() { @Test public void test_RingbufferReadOneCodec_encodeResponse() { - int fileClientMessageIndex = 660; + int fileClientMessageIndex = 654; ClientMessage encoded = RingbufferReadOneCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5845,7 +5799,7 @@ public void test_RingbufferReadOneCodec_encodeResponse() { @Test public void test_RingbufferAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 661; + int fileClientMessageIndex = 655; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferAddAllCodec.RequestParameters parameters = RingbufferAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5855,7 +5809,7 @@ public void test_RingbufferAddAllCodec_decodeRequest() { @Test public void test_RingbufferAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 662; + int fileClientMessageIndex = 656; ClientMessage encoded = RingbufferAddAllCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5863,7 +5817,7 @@ public void test_RingbufferAddAllCodec_encodeResponse() { @Test public void test_RingbufferReadManyCodec_decodeRequest() { - int fileClientMessageIndex = 663; + int fileClientMessageIndex = 657; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferReadManyCodec.RequestParameters parameters = RingbufferReadManyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5875,7 +5829,7 @@ public void test_RingbufferReadManyCodec_decodeRequest() { @Test public void test_RingbufferReadManyCodec_encodeResponse() { - int fileClientMessageIndex = 664; + int fileClientMessageIndex = 658; ClientMessage encoded = RingbufferReadManyCodec.encodeResponse(anInt, aListOfData, null, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5883,14 +5837,14 @@ public void test_RingbufferReadManyCodec_encodeResponse() { @Test public void test_DurableExecutorShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 665; + int fileClientMessageIndex = 659; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, DurableExecutorShutdownCodec.decodeRequest(fromFile))); } @Test public void test_DurableExecutorShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 666; + int fileClientMessageIndex = 660; ClientMessage encoded = DurableExecutorShutdownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5898,14 +5852,14 @@ public void test_DurableExecutorShutdownCodec_encodeResponse() { @Test public void test_DurableExecutorIsShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 667; + int fileClientMessageIndex = 661; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, DurableExecutorIsShutdownCodec.decodeRequest(fromFile))); } @Test public void test_DurableExecutorIsShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 668; + int fileClientMessageIndex = 662; ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5913,7 +5867,7 @@ public void test_DurableExecutorIsShutdownCodec_encodeResponse() { @Test public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 669; + int fileClientMessageIndex = 663; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorSubmitToPartitionCodec.RequestParameters parameters = DurableExecutorSubmitToPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5922,7 +5876,7 @@ public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { @Test public void test_DurableExecutorSubmitToPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 670; + int fileClientMessageIndex = 664; ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5930,7 +5884,7 @@ public void test_DurableExecutorSubmitToPartitionCodec_encodeResponse() { @Test public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { - int fileClientMessageIndex = 671; + int fileClientMessageIndex = 665; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorRetrieveResultCodec.RequestParameters parameters = DurableExecutorRetrieveResultCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5939,7 +5893,7 @@ public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { @Test public void test_DurableExecutorRetrieveResultCodec_encodeResponse() { - int fileClientMessageIndex = 672; + int fileClientMessageIndex = 666; ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5947,7 +5901,7 @@ public void test_DurableExecutorRetrieveResultCodec_encodeResponse() { @Test public void test_DurableExecutorDisposeResultCodec_decodeRequest() { - int fileClientMessageIndex = 673; + int fileClientMessageIndex = 667; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorDisposeResultCodec.RequestParameters parameters = DurableExecutorDisposeResultCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5956,7 +5910,7 @@ public void test_DurableExecutorDisposeResultCodec_decodeRequest() { @Test public void test_DurableExecutorDisposeResultCodec_encodeResponse() { - int fileClientMessageIndex = 674; + int fileClientMessageIndex = 668; ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5964,7 +5918,7 @@ public void test_DurableExecutorDisposeResultCodec_encodeResponse() { @Test public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { - int fileClientMessageIndex = 675; + int fileClientMessageIndex = 669; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorRetrieveAndDisposeResultCodec.RequestParameters parameters = DurableExecutorRetrieveAndDisposeResultCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5973,7 +5927,7 @@ public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { @Test public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeResponse() { - int fileClientMessageIndex = 676; + int fileClientMessageIndex = 670; ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5981,7 +5935,7 @@ public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeResponse() { @Test public void test_CardinalityEstimatorAddCodec_decodeRequest() { - int fileClientMessageIndex = 677; + int fileClientMessageIndex = 671; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CardinalityEstimatorAddCodec.RequestParameters parameters = CardinalityEstimatorAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5990,7 +5944,7 @@ public void test_CardinalityEstimatorAddCodec_decodeRequest() { @Test public void test_CardinalityEstimatorAddCodec_encodeResponse() { - int fileClientMessageIndex = 678; + int fileClientMessageIndex = 672; ClientMessage encoded = CardinalityEstimatorAddCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5998,14 +5952,14 @@ public void test_CardinalityEstimatorAddCodec_encodeResponse() { @Test public void test_CardinalityEstimatorEstimateCodec_decodeRequest() { - int fileClientMessageIndex = 679; + int fileClientMessageIndex = 673; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CardinalityEstimatorEstimateCodec.decodeRequest(fromFile))); } @Test public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { - int fileClientMessageIndex = 680; + int fileClientMessageIndex = 674; ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6013,7 +5967,7 @@ public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { @Test public void test_ScheduledExecutorShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 681; + int fileClientMessageIndex = 675; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorShutdownCodec.RequestParameters parameters = ScheduledExecutorShutdownCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6022,7 +5976,7 @@ public void test_ScheduledExecutorShutdownCodec_decodeRequest() { @Test public void test_ScheduledExecutorShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 682; + int fileClientMessageIndex = 676; ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6030,7 +5984,7 @@ public void test_ScheduledExecutorShutdownCodec_encodeResponse() { @Test public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 683; + int fileClientMessageIndex = 677; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorSubmitToPartitionCodec.RequestParameters parameters = ScheduledExecutorSubmitToPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6045,7 +5999,7 @@ public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorSubmitToPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 684; + int fileClientMessageIndex = 678; ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6053,7 +6007,7 @@ public void test_ScheduledExecutorSubmitToPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { - int fileClientMessageIndex = 685; + int fileClientMessageIndex = 679; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorSubmitToMemberCodec.RequestParameters parameters = ScheduledExecutorSubmitToMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6069,7 +6023,7 @@ public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorSubmitToMemberCodec_encodeResponse() { - int fileClientMessageIndex = 686; + int fileClientMessageIndex = 680; ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6077,14 +6031,14 @@ public void test_ScheduledExecutorSubmitToMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeRequest() { - int fileClientMessageIndex = 687; + int fileClientMessageIndex = 681; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ScheduledExecutorGetAllScheduledFuturesCodec.decodeRequest(fromFile))); } @Test public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { - int fileClientMessageIndex = 688; + int fileClientMessageIndex = 682; ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeResponse(aListOfScheduledTaskHandler); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6092,7 +6046,7 @@ public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 689; + int fileClientMessageIndex = 683; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetStatsFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6101,7 +6055,7 @@ public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 690; + int fileClientMessageIndex = 684; ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6109,7 +6063,7 @@ public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 691; + int fileClientMessageIndex = 685; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetStatsFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6119,7 +6073,7 @@ public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 692; + int fileClientMessageIndex = 686; ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6127,7 +6081,7 @@ public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 693; + int fileClientMessageIndex = 687; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetDelayFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6136,7 +6090,7 @@ public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 694; + int fileClientMessageIndex = 688; ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6144,7 +6098,7 @@ public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 695; + int fileClientMessageIndex = 689; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetDelayFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6154,7 +6108,7 @@ public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 696; + int fileClientMessageIndex = 690; ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6162,7 +6116,7 @@ public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 697; + int fileClientMessageIndex = 691; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorCancelFromPartitionCodec.RequestParameters parameters = ScheduledExecutorCancelFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6172,7 +6126,7 @@ public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorCancelFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 698; + int fileClientMessageIndex = 692; ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6180,7 +6134,7 @@ public void test_ScheduledExecutorCancelFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 699; + int fileClientMessageIndex = 693; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorCancelFromMemberCodec.RequestParameters parameters = ScheduledExecutorCancelFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6191,7 +6145,7 @@ public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorCancelFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 700; + int fileClientMessageIndex = 694; ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6199,7 +6153,7 @@ public void test_ScheduledExecutorCancelFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 701; + int fileClientMessageIndex = 695; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsCancelledFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6208,7 +6162,7 @@ public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() @Test public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 702; + int fileClientMessageIndex = 696; ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6216,7 +6170,7 @@ public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeResponse() @Test public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 703; + int fileClientMessageIndex = 697; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsCancelledFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6226,7 +6180,7 @@ public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 704; + int fileClientMessageIndex = 698; ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6234,7 +6188,7 @@ public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 705; + int fileClientMessageIndex = 699; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsDoneFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6243,7 +6197,7 @@ public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 706; + int fileClientMessageIndex = 700; ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6251,7 +6205,7 @@ public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 707; + int fileClientMessageIndex = 701; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsDoneFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6261,7 +6215,7 @@ public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 708; + int fileClientMessageIndex = 702; ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6269,7 +6223,7 @@ public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 709; + int fileClientMessageIndex = 703; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetResultFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetResultFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6278,7 +6232,7 @@ public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 710; + int fileClientMessageIndex = 704; ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6286,7 +6240,7 @@ public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 711; + int fileClientMessageIndex = 705; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetResultFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetResultFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6296,7 +6250,7 @@ public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetResultFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 712; + int fileClientMessageIndex = 706; ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6304,7 +6258,7 @@ public void test_ScheduledExecutorGetResultFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 713; + int fileClientMessageIndex = 707; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorDisposeFromPartitionCodec.RequestParameters parameters = ScheduledExecutorDisposeFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6313,7 +6267,7 @@ public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 714; + int fileClientMessageIndex = 708; ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6321,7 +6275,7 @@ public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 715; + int fileClientMessageIndex = 709; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorDisposeFromMemberCodec.RequestParameters parameters = ScheduledExecutorDisposeFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6331,7 +6285,7 @@ public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorDisposeFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 716; + int fileClientMessageIndex = 710; ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6339,7 +6293,7 @@ public void test_ScheduledExecutorDisposeFromMemberCodec_encodeResponse() { @Test public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 717; + int fileClientMessageIndex = 711; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddMultiMapConfigCodec.RequestParameters parameters = DynamicConfigAddMultiMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6356,7 +6310,7 @@ public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddMultiMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 718; + int fileClientMessageIndex = 712; ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6364,7 +6318,7 @@ public void test_DynamicConfigAddMultiMapConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { - int fileClientMessageIndex = 719; + int fileClientMessageIndex = 713; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddRingbufferConfigCodec.RequestParameters parameters = DynamicConfigAddRingbufferConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6381,7 +6335,7 @@ public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddRingbufferConfigCodec_encodeResponse() { - int fileClientMessageIndex = 720; + int fileClientMessageIndex = 714; ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6389,7 +6343,7 @@ public void test_DynamicConfigAddRingbufferConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 721; + int fileClientMessageIndex = 715; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddCardinalityEstimatorConfigCodec.RequestParameters parameters = DynamicConfigAddCardinalityEstimatorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6402,7 +6356,7 @@ public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() @Test public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 722; + int fileClientMessageIndex = 716; ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6410,7 +6364,7 @@ public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeResponse( @Test public void test_DynamicConfigAddListConfigCodec_decodeRequest() { - int fileClientMessageIndex = 723; + int fileClientMessageIndex = 717; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddListConfigCodec.RequestParameters parameters = DynamicConfigAddListConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6426,7 +6380,7 @@ public void test_DynamicConfigAddListConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddListConfigCodec_encodeResponse() { - int fileClientMessageIndex = 724; + int fileClientMessageIndex = 718; ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6434,7 +6388,7 @@ public void test_DynamicConfigAddListConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { - int fileClientMessageIndex = 725; + int fileClientMessageIndex = 719; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddSetConfigCodec.RequestParameters parameters = DynamicConfigAddSetConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6450,7 +6404,7 @@ public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddSetConfigCodec_encodeResponse() { - int fileClientMessageIndex = 726; + int fileClientMessageIndex = 720; ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6458,7 +6412,7 @@ public void test_DynamicConfigAddSetConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 727; + int fileClientMessageIndex = 721; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddReplicatedMapConfigCodec.RequestParameters parameters = DynamicConfigAddReplicatedMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6473,7 +6427,7 @@ public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 728; + int fileClientMessageIndex = 722; ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6481,7 +6435,7 @@ public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { - int fileClientMessageIndex = 729; + int fileClientMessageIndex = 723; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddTopicConfigCodec.RequestParameters parameters = DynamicConfigAddTopicConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6493,7 +6447,7 @@ public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddTopicConfigCodec_encodeResponse() { - int fileClientMessageIndex = 730; + int fileClientMessageIndex = 724; ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6501,7 +6455,7 @@ public void test_DynamicConfigAddTopicConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 731; + int fileClientMessageIndex = 725; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddExecutorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6513,7 +6467,7 @@ public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddExecutorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 732; + int fileClientMessageIndex = 726; ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6521,7 +6475,7 @@ public void test_DynamicConfigAddExecutorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 733; + int fileClientMessageIndex = 727; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddDurableExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddDurableExecutorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6535,7 +6489,7 @@ public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 734; + int fileClientMessageIndex = 728; ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6543,7 +6497,7 @@ public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 735; + int fileClientMessageIndex = 729; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddScheduledExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddScheduledExecutorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6559,7 +6513,7 @@ public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 736; + int fileClientMessageIndex = 730; ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6567,7 +6521,7 @@ public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { - int fileClientMessageIndex = 737; + int fileClientMessageIndex = 731; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddQueueConfigCodec.RequestParameters parameters = DynamicConfigAddQueueConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6587,7 +6541,7 @@ public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddQueueConfigCodec_encodeResponse() { - int fileClientMessageIndex = 738; + int fileClientMessageIndex = 732; ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6595,7 +6549,7 @@ public void test_DynamicConfigAddQueueConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 739; + int fileClientMessageIndex = 733; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddMapConfigCodec.RequestParameters parameters = DynamicConfigAddMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6629,7 +6583,7 @@ public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 740; + int fileClientMessageIndex = 734; ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6637,7 +6591,7 @@ public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { - int fileClientMessageIndex = 741; + int fileClientMessageIndex = 735; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddReliableTopicConfigCodec.RequestParameters parameters = DynamicConfigAddReliableTopicConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6650,7 +6604,7 @@ public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddReliableTopicConfigCodec_encodeResponse() { - int fileClientMessageIndex = 742; + int fileClientMessageIndex = 736; ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6658,7 +6612,7 @@ public void test_DynamicConfigAddReliableTopicConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { - int fileClientMessageIndex = 743; + int fileClientMessageIndex = 737; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddCacheConfigCodec.RequestParameters parameters = DynamicConfigAddCacheConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6691,7 +6645,7 @@ public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { - int fileClientMessageIndex = 744; + int fileClientMessageIndex = 738; ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6699,7 +6653,7 @@ public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 745; + int fileClientMessageIndex = 739; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddFlakeIdGeneratorConfigCodec.RequestParameters parameters = DynamicConfigAddFlakeIdGeneratorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6715,7 +6669,7 @@ public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 746; + int fileClientMessageIndex = 740; ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6723,7 +6677,7 @@ public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { - int fileClientMessageIndex = 747; + int fileClientMessageIndex = 741; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddPNCounterConfigCodec.RequestParameters parameters = DynamicConfigAddPNCounterConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6734,7 +6688,7 @@ public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddPNCounterConfigCodec_encodeResponse() { - int fileClientMessageIndex = 748; + int fileClientMessageIndex = 742; ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6742,7 +6696,7 @@ public void test_DynamicConfigAddPNCounterConfigCodec_encodeResponse() { @Test public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { - int fileClientMessageIndex = 749; + int fileClientMessageIndex = 743; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FlakeIdGeneratorNewIdBatchCodec.RequestParameters parameters = FlakeIdGeneratorNewIdBatchCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6751,7 +6705,7 @@ public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { @Test public void test_FlakeIdGeneratorNewIdBatchCodec_encodeResponse() { - int fileClientMessageIndex = 750; + int fileClientMessageIndex = 744; ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeResponse(aLong, aLong, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6759,7 +6713,7 @@ public void test_FlakeIdGeneratorNewIdBatchCodec_encodeResponse() { @Test public void test_PNCounterGetCodec_decodeRequest() { - int fileClientMessageIndex = 751; + int fileClientMessageIndex = 745; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); PNCounterGetCodec.RequestParameters parameters = PNCounterGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6769,7 +6723,7 @@ public void test_PNCounterGetCodec_decodeRequest() { @Test public void test_PNCounterGetCodec_encodeResponse() { - int fileClientMessageIndex = 752; + int fileClientMessageIndex = 746; ClientMessage encoded = PNCounterGetCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6777,7 +6731,7 @@ public void test_PNCounterGetCodec_encodeResponse() { @Test public void test_PNCounterAddCodec_decodeRequest() { - int fileClientMessageIndex = 753; + int fileClientMessageIndex = 747; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); PNCounterAddCodec.RequestParameters parameters = PNCounterAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6789,7 +6743,7 @@ public void test_PNCounterAddCodec_decodeRequest() { @Test public void test_PNCounterAddCodec_encodeResponse() { - int fileClientMessageIndex = 754; + int fileClientMessageIndex = 748; ClientMessage encoded = PNCounterAddCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6797,14 +6751,14 @@ public void test_PNCounterAddCodec_encodeResponse() { @Test public void test_PNCounterGetConfiguredReplicaCountCodec_decodeRequest() { - int fileClientMessageIndex = 755; + int fileClientMessageIndex = 749; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, PNCounterGetConfiguredReplicaCountCodec.decodeRequest(fromFile))); } @Test public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { - int fileClientMessageIndex = 756; + int fileClientMessageIndex = 750; ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6812,14 +6766,14 @@ public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { @Test public void test_CPGroupCreateCPGroupCodec_decodeRequest() { - int fileClientMessageIndex = 757; + int fileClientMessageIndex = 751; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CPGroupCreateCPGroupCodec.decodeRequest(fromFile))); } @Test public void test_CPGroupCreateCPGroupCodec_encodeResponse() { - int fileClientMessageIndex = 758; + int fileClientMessageIndex = 752; ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeResponse(aRaftGroupId); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6827,7 +6781,7 @@ public void test_CPGroupCreateCPGroupCodec_encodeResponse() { @Test public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { - int fileClientMessageIndex = 759; + int fileClientMessageIndex = 753; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPGroupDestroyCPObjectCodec.RequestParameters parameters = CPGroupDestroyCPObjectCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6837,7 +6791,7 @@ public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { @Test public void test_CPGroupDestroyCPObjectCodec_encodeResponse() { - int fileClientMessageIndex = 760; + int fileClientMessageIndex = 754; ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6845,7 +6799,7 @@ public void test_CPGroupDestroyCPObjectCodec_encodeResponse() { @Test public void test_CPSessionCreateSessionCodec_decodeRequest() { - int fileClientMessageIndex = 761; + int fileClientMessageIndex = 755; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPSessionCreateSessionCodec.RequestParameters parameters = CPSessionCreateSessionCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6854,7 +6808,7 @@ public void test_CPSessionCreateSessionCodec_decodeRequest() { @Test public void test_CPSessionCreateSessionCodec_encodeResponse() { - int fileClientMessageIndex = 762; + int fileClientMessageIndex = 756; ClientMessage encoded = CPSessionCreateSessionCodec.encodeResponse(aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6862,7 +6816,7 @@ public void test_CPSessionCreateSessionCodec_encodeResponse() { @Test public void test_CPSessionCloseSessionCodec_decodeRequest() { - int fileClientMessageIndex = 763; + int fileClientMessageIndex = 757; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPSessionCloseSessionCodec.RequestParameters parameters = CPSessionCloseSessionCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6871,7 +6825,7 @@ public void test_CPSessionCloseSessionCodec_decodeRequest() { @Test public void test_CPSessionCloseSessionCodec_encodeResponse() { - int fileClientMessageIndex = 764; + int fileClientMessageIndex = 758; ClientMessage encoded = CPSessionCloseSessionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6879,7 +6833,7 @@ public void test_CPSessionCloseSessionCodec_encodeResponse() { @Test public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { - int fileClientMessageIndex = 765; + int fileClientMessageIndex = 759; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPSessionHeartbeatSessionCodec.RequestParameters parameters = CPSessionHeartbeatSessionCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6888,7 +6842,7 @@ public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { @Test public void test_CPSessionHeartbeatSessionCodec_encodeResponse() { - int fileClientMessageIndex = 766; + int fileClientMessageIndex = 760; ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6896,14 +6850,14 @@ public void test_CPSessionHeartbeatSessionCodec_encodeResponse() { @Test public void test_CPSessionGenerateThreadIdCodec_decodeRequest() { - int fileClientMessageIndex = 767; + int fileClientMessageIndex = 761; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aRaftGroupId, CPSessionGenerateThreadIdCodec.decodeRequest(fromFile))); } @Test public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { - int fileClientMessageIndex = 768; + int fileClientMessageIndex = 762; ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6911,7 +6865,7 @@ public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { @Test public void test_MCReadMetricsCodec_decodeRequest() { - int fileClientMessageIndex = 769; + int fileClientMessageIndex = 763; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCReadMetricsCodec.RequestParameters parameters = MCReadMetricsCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.uuid)); @@ -6920,7 +6874,7 @@ public void test_MCReadMetricsCodec_decodeRequest() { @Test public void test_MCReadMetricsCodec_encodeResponse() { - int fileClientMessageIndex = 770; + int fileClientMessageIndex = 764; ClientMessage encoded = MCReadMetricsCodec.encodeResponse(aListOfLongToByteArray, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6928,14 +6882,14 @@ public void test_MCReadMetricsCodec_encodeResponse() { @Test public void test_MCChangeClusterStateCodec_decodeRequest() { - int fileClientMessageIndex = 771; + int fileClientMessageIndex = 765; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anInt, MCChangeClusterStateCodec.decodeRequest(fromFile))); } @Test public void test_MCChangeClusterStateCodec_encodeResponse() { - int fileClientMessageIndex = 772; + int fileClientMessageIndex = 766; ClientMessage encoded = MCChangeClusterStateCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6943,14 +6897,14 @@ public void test_MCChangeClusterStateCodec_encodeResponse() { @Test public void test_MCGetMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 773; + int fileClientMessageIndex = 767; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MCGetMapConfigCodec.decodeRequest(fromFile))); } @Test public void test_MCGetMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 774; + int fileClientMessageIndex = 768; ClientMessage encoded = MCGetMapConfigCodec.encodeResponse(anInt, anInt, anInt, anInt, anInt, anInt, anInt, aBoolean, anInt, aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6958,7 +6912,7 @@ public void test_MCGetMapConfigCodec_encodeResponse() { @Test public void test_MCUpdateMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 775; + int fileClientMessageIndex = 769; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCUpdateMapConfigCodec.RequestParameters parameters = MCUpdateMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -6972,7 +6926,7 @@ public void test_MCUpdateMapConfigCodec_decodeRequest() { @Test public void test_MCUpdateMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 776; + int fileClientMessageIndex = 770; ClientMessage encoded = MCUpdateMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6980,12 +6934,12 @@ public void test_MCUpdateMapConfigCodec_encodeResponse() { @Test public void test_MCGetMemberConfigCodec_decodeRequest() { - int fileClientMessageIndex = 777; + int fileClientMessageIndex = 771; } @Test public void test_MCGetMemberConfigCodec_encodeResponse() { - int fileClientMessageIndex = 778; + int fileClientMessageIndex = 772; ClientMessage encoded = MCGetMemberConfigCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6993,12 +6947,12 @@ public void test_MCGetMemberConfigCodec_encodeResponse() { @Test public void test_MCRunGcCodec_decodeRequest() { - int fileClientMessageIndex = 779; + int fileClientMessageIndex = 773; } @Test public void test_MCRunGcCodec_encodeResponse() { - int fileClientMessageIndex = 780; + int fileClientMessageIndex = 774; ClientMessage encoded = MCRunGcCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7006,14 +6960,14 @@ public void test_MCRunGcCodec_encodeResponse() { @Test public void test_MCGetThreadDumpCodec_decodeRequest() { - int fileClientMessageIndex = 781; + int fileClientMessageIndex = 775; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MCGetThreadDumpCodec.decodeRequest(fromFile))); } @Test public void test_MCGetThreadDumpCodec_encodeResponse() { - int fileClientMessageIndex = 782; + int fileClientMessageIndex = 776; ClientMessage encoded = MCGetThreadDumpCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7021,12 +6975,12 @@ public void test_MCGetThreadDumpCodec_encodeResponse() { @Test public void test_MCShutdownMemberCodec_decodeRequest() { - int fileClientMessageIndex = 783; + int fileClientMessageIndex = 777; } @Test public void test_MCShutdownMemberCodec_encodeResponse() { - int fileClientMessageIndex = 784; + int fileClientMessageIndex = 778; ClientMessage encoded = MCShutdownMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7034,12 +6988,12 @@ public void test_MCShutdownMemberCodec_encodeResponse() { @Test public void test_MCPromoteLiteMemberCodec_decodeRequest() { - int fileClientMessageIndex = 785; + int fileClientMessageIndex = 779; } @Test public void test_MCPromoteLiteMemberCodec_encodeResponse() { - int fileClientMessageIndex = 786; + int fileClientMessageIndex = 780; ClientMessage encoded = MCPromoteLiteMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7047,12 +7001,12 @@ public void test_MCPromoteLiteMemberCodec_encodeResponse() { @Test public void test_MCGetSystemPropertiesCodec_decodeRequest() { - int fileClientMessageIndex = 787; + int fileClientMessageIndex = 781; } @Test public void test_MCGetSystemPropertiesCodec_encodeResponse() { - int fileClientMessageIndex = 788; + int fileClientMessageIndex = 782; ClientMessage encoded = MCGetSystemPropertiesCodec.encodeResponse(aListOfStringToString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7060,12 +7014,12 @@ public void test_MCGetSystemPropertiesCodec_encodeResponse() { @Test public void test_MCGetTimedMemberStateCodec_decodeRequest() { - int fileClientMessageIndex = 789; + int fileClientMessageIndex = 783; } @Test public void test_MCGetTimedMemberStateCodec_encodeResponse() { - int fileClientMessageIndex = 790; + int fileClientMessageIndex = 784; ClientMessage encoded = MCGetTimedMemberStateCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7073,14 +7027,14 @@ public void test_MCGetTimedMemberStateCodec_encodeResponse() { @Test public void test_MCMatchMCConfigCodec_decodeRequest() { - int fileClientMessageIndex = 791; + int fileClientMessageIndex = 785; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MCMatchMCConfigCodec.decodeRequest(fromFile))); } @Test public void test_MCMatchMCConfigCodec_encodeResponse() { - int fileClientMessageIndex = 792; + int fileClientMessageIndex = 786; ClientMessage encoded = MCMatchMCConfigCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7088,7 +7042,7 @@ public void test_MCMatchMCConfigCodec_encodeResponse() { @Test public void test_MCApplyMCConfigCodec_decodeRequest() { - int fileClientMessageIndex = 793; + int fileClientMessageIndex = 787; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCApplyMCConfigCodec.RequestParameters parameters = MCApplyMCConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.eTag)); @@ -7098,7 +7052,7 @@ public void test_MCApplyMCConfigCodec_decodeRequest() { @Test public void test_MCApplyMCConfigCodec_encodeResponse() { - int fileClientMessageIndex = 794; + int fileClientMessageIndex = 788; ClientMessage encoded = MCApplyMCConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7106,12 +7060,12 @@ public void test_MCApplyMCConfigCodec_encodeResponse() { @Test public void test_MCGetClusterMetadataCodec_decodeRequest() { - int fileClientMessageIndex = 795; + int fileClientMessageIndex = 789; } @Test public void test_MCGetClusterMetadataCodec_encodeResponse() { - int fileClientMessageIndex = 796; + int fileClientMessageIndex = 790; ClientMessage encoded = MCGetClusterMetadataCodec.encodeResponse(aByte, aString, null, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7119,12 +7073,12 @@ public void test_MCGetClusterMetadataCodec_encodeResponse() { @Test public void test_MCShutdownClusterCodec_decodeRequest() { - int fileClientMessageIndex = 797; + int fileClientMessageIndex = 791; } @Test public void test_MCShutdownClusterCodec_encodeResponse() { - int fileClientMessageIndex = 798; + int fileClientMessageIndex = 792; ClientMessage encoded = MCShutdownClusterCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7132,7 +7086,7 @@ public void test_MCShutdownClusterCodec_encodeResponse() { @Test public void test_MCChangeClusterVersionCodec_decodeRequest() { - int fileClientMessageIndex = 799; + int fileClientMessageIndex = 793; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCChangeClusterVersionCodec.RequestParameters parameters = MCChangeClusterVersionCodec.decodeRequest(fromFile); assertTrue(isEqual(aByte, parameters.majorVersion)); @@ -7141,7 +7095,7 @@ public void test_MCChangeClusterVersionCodec_decodeRequest() { @Test public void test_MCChangeClusterVersionCodec_encodeResponse() { - int fileClientMessageIndex = 800; + int fileClientMessageIndex = 794; ClientMessage encoded = MCChangeClusterVersionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7149,7 +7103,7 @@ public void test_MCChangeClusterVersionCodec_encodeResponse() { @Test public void test_MCRunScriptCodec_decodeRequest() { - int fileClientMessageIndex = 801; + int fileClientMessageIndex = 795; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCRunScriptCodec.RequestParameters parameters = MCRunScriptCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.engine)); @@ -7158,7 +7112,7 @@ public void test_MCRunScriptCodec_decodeRequest() { @Test public void test_MCRunScriptCodec_encodeResponse() { - int fileClientMessageIndex = 802; + int fileClientMessageIndex = 796; ClientMessage encoded = MCRunScriptCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7166,7 +7120,7 @@ public void test_MCRunScriptCodec_encodeResponse() { @Test public void test_MCRunConsoleCommandCodec_decodeRequest() { - int fileClientMessageIndex = 803; + int fileClientMessageIndex = 797; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCRunConsoleCommandCodec.RequestParameters parameters = MCRunConsoleCommandCodec.decodeRequest(fromFile); assertTrue(isEqual(null, parameters.namespace)); @@ -7175,7 +7129,7 @@ public void test_MCRunConsoleCommandCodec_decodeRequest() { @Test public void test_MCRunConsoleCommandCodec_encodeResponse() { - int fileClientMessageIndex = 804; + int fileClientMessageIndex = 798; ClientMessage encoded = MCRunConsoleCommandCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7183,7 +7137,7 @@ public void test_MCRunConsoleCommandCodec_encodeResponse() { @Test public void test_MCChangeWanReplicationStateCodec_decodeRequest() { - int fileClientMessageIndex = 805; + int fileClientMessageIndex = 799; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCChangeWanReplicationStateCodec.RequestParameters parameters = MCChangeWanReplicationStateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7193,7 +7147,7 @@ public void test_MCChangeWanReplicationStateCodec_decodeRequest() { @Test public void test_MCChangeWanReplicationStateCodec_encodeResponse() { - int fileClientMessageIndex = 806; + int fileClientMessageIndex = 800; ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7201,7 +7155,7 @@ public void test_MCChangeWanReplicationStateCodec_encodeResponse() { @Test public void test_MCClearWanQueuesCodec_decodeRequest() { - int fileClientMessageIndex = 807; + int fileClientMessageIndex = 801; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCClearWanQueuesCodec.RequestParameters parameters = MCClearWanQueuesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7210,7 +7164,7 @@ public void test_MCClearWanQueuesCodec_decodeRequest() { @Test public void test_MCClearWanQueuesCodec_encodeResponse() { - int fileClientMessageIndex = 808; + int fileClientMessageIndex = 802; ClientMessage encoded = MCClearWanQueuesCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7218,7 +7172,7 @@ public void test_MCClearWanQueuesCodec_encodeResponse() { @Test public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { - int fileClientMessageIndex = 809; + int fileClientMessageIndex = 803; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCAddWanBatchPublisherConfigCodec.RequestParameters parameters = MCAddWanBatchPublisherConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -7235,7 +7189,7 @@ public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { @Test public void test_MCAddWanBatchPublisherConfigCodec_encodeResponse() { - int fileClientMessageIndex = 810; + int fileClientMessageIndex = 804; ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeResponse(aListOfStrings, aListOfStrings); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7243,7 +7197,7 @@ public void test_MCAddWanBatchPublisherConfigCodec_encodeResponse() { @Test public void test_MCWanSyncMapCodec_decodeRequest() { - int fileClientMessageIndex = 811; + int fileClientMessageIndex = 805; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCWanSyncMapCodec.RequestParameters parameters = MCWanSyncMapCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7254,7 +7208,7 @@ public void test_MCWanSyncMapCodec_decodeRequest() { @Test public void test_MCWanSyncMapCodec_encodeResponse() { - int fileClientMessageIndex = 812; + int fileClientMessageIndex = 806; ClientMessage encoded = MCWanSyncMapCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7262,7 +7216,7 @@ public void test_MCWanSyncMapCodec_encodeResponse() { @Test public void test_MCCheckWanConsistencyCodec_decodeRequest() { - int fileClientMessageIndex = 813; + int fileClientMessageIndex = 807; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCCheckWanConsistencyCodec.RequestParameters parameters = MCCheckWanConsistencyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7272,7 +7226,7 @@ public void test_MCCheckWanConsistencyCodec_decodeRequest() { @Test public void test_MCCheckWanConsistencyCodec_encodeResponse() { - int fileClientMessageIndex = 814; + int fileClientMessageIndex = 808; ClientMessage encoded = MCCheckWanConsistencyCodec.encodeResponse(null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7280,12 +7234,12 @@ public void test_MCCheckWanConsistencyCodec_encodeResponse() { @Test public void test_MCPollMCEventsCodec_decodeRequest() { - int fileClientMessageIndex = 815; + int fileClientMessageIndex = 809; } @Test public void test_MCPollMCEventsCodec_encodeResponse() { - int fileClientMessageIndex = 816; + int fileClientMessageIndex = 810; ClientMessage encoded = MCPollMCEventsCodec.encodeResponse(aListOfMCEvents); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7293,12 +7247,12 @@ public void test_MCPollMCEventsCodec_encodeResponse() { @Test public void test_MCGetCPMembersCodec_decodeRequest() { - int fileClientMessageIndex = 817; + int fileClientMessageIndex = 811; } @Test public void test_MCGetCPMembersCodec_encodeResponse() { - int fileClientMessageIndex = 818; + int fileClientMessageIndex = 812; ClientMessage encoded = MCGetCPMembersCodec.encodeResponse(aListOfUUIDToUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7306,12 +7260,12 @@ public void test_MCGetCPMembersCodec_encodeResponse() { @Test public void test_MCPromoteToCPMemberCodec_decodeRequest() { - int fileClientMessageIndex = 819; + int fileClientMessageIndex = 813; } @Test public void test_MCPromoteToCPMemberCodec_encodeResponse() { - int fileClientMessageIndex = 820; + int fileClientMessageIndex = 814; ClientMessage encoded = MCPromoteToCPMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7319,14 +7273,14 @@ public void test_MCPromoteToCPMemberCodec_encodeResponse() { @Test public void test_MCRemoveCPMemberCodec_decodeRequest() { - int fileClientMessageIndex = 821; + int fileClientMessageIndex = 815; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MCRemoveCPMemberCodec.decodeRequest(fromFile))); } @Test public void test_MCRemoveCPMemberCodec_encodeResponse() { - int fileClientMessageIndex = 822; + int fileClientMessageIndex = 816; ClientMessage encoded = MCRemoveCPMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7334,12 +7288,12 @@ public void test_MCRemoveCPMemberCodec_encodeResponse() { @Test public void test_MCResetCPSubsystemCodec_decodeRequest() { - int fileClientMessageIndex = 823; + int fileClientMessageIndex = 817; } @Test public void test_MCResetCPSubsystemCodec_encodeResponse() { - int fileClientMessageIndex = 824; + int fileClientMessageIndex = 818; ClientMessage encoded = MCResetCPSubsystemCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7347,12 +7301,12 @@ public void test_MCResetCPSubsystemCodec_encodeResponse() { @Test public void test_MCTriggerPartialStartCodec_decodeRequest() { - int fileClientMessageIndex = 825; + int fileClientMessageIndex = 819; } @Test public void test_MCTriggerPartialStartCodec_encodeResponse() { - int fileClientMessageIndex = 826; + int fileClientMessageIndex = 820; ClientMessage encoded = MCTriggerPartialStartCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7360,12 +7314,12 @@ public void test_MCTriggerPartialStartCodec_encodeResponse() { @Test public void test_MCTriggerForceStartCodec_decodeRequest() { - int fileClientMessageIndex = 827; + int fileClientMessageIndex = 821; } @Test public void test_MCTriggerForceStartCodec_encodeResponse() { - int fileClientMessageIndex = 828; + int fileClientMessageIndex = 822; ClientMessage encoded = MCTriggerForceStartCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7373,12 +7327,12 @@ public void test_MCTriggerForceStartCodec_encodeResponse() { @Test public void test_MCTriggerHotRestartBackupCodec_decodeRequest() { - int fileClientMessageIndex = 829; + int fileClientMessageIndex = 823; } @Test public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { - int fileClientMessageIndex = 830; + int fileClientMessageIndex = 824; ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7386,12 +7340,12 @@ public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { @Test public void test_MCInterruptHotRestartBackupCodec_decodeRequest() { - int fileClientMessageIndex = 831; + int fileClientMessageIndex = 825; } @Test public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { - int fileClientMessageIndex = 832; + int fileClientMessageIndex = 826; ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7399,7 +7353,7 @@ public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { @Test public void test_SqlExecuteCodec_decodeRequest() { - int fileClientMessageIndex = 833; + int fileClientMessageIndex = 827; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SqlExecuteCodec.RequestParameters parameters = SqlExecuteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.sql)); @@ -7410,7 +7364,7 @@ public void test_SqlExecuteCodec_decodeRequest() { @Test public void test_SqlExecuteCodec_encodeResponse() { - int fileClientMessageIndex = 834; + int fileClientMessageIndex = 828; ClientMessage encoded = SqlExecuteCodec.encodeResponse(null, null, null, aBoolean, aLong, null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7418,7 +7372,7 @@ public void test_SqlExecuteCodec_encodeResponse() { @Test public void test_SqlFetchCodec_decodeRequest() { - int fileClientMessageIndex = 835; + int fileClientMessageIndex = 829; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SqlFetchCodec.RequestParameters parameters = SqlFetchCodec.decodeRequest(fromFile); assertTrue(isEqual(anSqlQueryId, parameters.queryId)); @@ -7427,7 +7381,7 @@ public void test_SqlFetchCodec_decodeRequest() { @Test public void test_SqlFetchCodec_encodeResponse() { - int fileClientMessageIndex = 836; + int fileClientMessageIndex = 830; ClientMessage encoded = SqlFetchCodec.encodeResponse(null, aBoolean, null); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7435,14 +7389,14 @@ public void test_SqlFetchCodec_encodeResponse() { @Test public void test_SqlCloseCodec_decodeRequest() { - int fileClientMessageIndex = 837; + int fileClientMessageIndex = 831; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anSqlQueryId, SqlCloseCodec.decodeRequest(fromFile))); } @Test public void test_SqlCloseCodec_encodeResponse() { - int fileClientMessageIndex = 838; + int fileClientMessageIndex = 832; ClientMessage encoded = SqlCloseCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7450,14 +7404,14 @@ public void test_SqlCloseCodec_encodeResponse() { @Test public void test_CPSubsystemAddMembershipListenerCodec_decodeRequest() { - int fileClientMessageIndex = 839; + int fileClientMessageIndex = 833; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, CPSubsystemAddMembershipListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { - int fileClientMessageIndex = 840; + int fileClientMessageIndex = 834; ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7465,7 +7419,7 @@ public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { @Test public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEvent() { - int fileClientMessageIndex = 841; + int fileClientMessageIndex = 835; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeMembershipEventEvent(aCpMember, aByte); compareClientMessages(fromFile, encoded); @@ -7473,14 +7427,14 @@ public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEven @Test public void test_CPSubsystemRemoveMembershipListenerCodec_decodeRequest() { - int fileClientMessageIndex = 842; + int fileClientMessageIndex = 836; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, CPSubsystemRemoveMembershipListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { - int fileClientMessageIndex = 843; + int fileClientMessageIndex = 837; ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7488,14 +7442,14 @@ public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { @Test public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeRequest() { - int fileClientMessageIndex = 844; + int fileClientMessageIndex = 838; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, CPSubsystemAddGroupAvailabilityListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { - int fileClientMessageIndex = 845; + int fileClientMessageIndex = 839; ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7503,7 +7457,7 @@ public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { @Test public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailabilityEventEvent() { - int fileClientMessageIndex = 846; + int fileClientMessageIndex = 840; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeGroupAvailabilityEventEvent(aRaftGroupId, aListOfCpMembers, aListOfCpMembers); compareClientMessages(fromFile, encoded); @@ -7511,14 +7465,14 @@ public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailab @Test public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeRequest() { - int fileClientMessageIndex = 847; + int fileClientMessageIndex = 841; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeResponse() { - int fileClientMessageIndex = 848; + int fileClientMessageIndex = 842; ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_2.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_2.java new file mode 100644 index 0000000000000..156717e54c292 --- /dev/null +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityNullTest_2_2.java @@ -0,0 +1,7552 @@ +/* + * Copyright (c) 2008-2020, 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_2 { + private List clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.2.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_MapPutCodec_decodeRequest() { + int fileClientMessageIndex = 43; + 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 = 44; + ClientMessage encoded = MapPutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeRequest() { + int fileClientMessageIndex = 45; + 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 = 46; + ClientMessage encoded = MapGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 47; + 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 = 48; + ClientMessage encoded = MapRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 49; + 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 = 50; + ClientMessage encoded = MapReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 51; + 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 = 52; + ClientMessage encoded = MapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 53; + 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 = 54; + ClientMessage encoded = MapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 55; + 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 = 56; + ClientMessage encoded = MapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 57; + 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 = 58; + ClientMessage encoded = MapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 59; + 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 = 60; + ClientMessage encoded = MapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapFlushCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapFlushCodec_encodeResponse() { + int fileClientMessageIndex = 62; + ClientMessage encoded = MapFlushCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 63; + 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 = 64; + ClientMessage encoded = MapTryRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryPutCodec_decodeRequest() { + int fileClientMessageIndex = 65; + 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 = 66; + ClientMessage encoded = MapTryPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientCodec_decodeRequest() { + int fileClientMessageIndex = 67; + 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 = 68; + ClientMessage encoded = MapPutTransientCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 69; + 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 = 70; + ClientMessage encoded = MapPutIfAbsentCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetCodec_decodeRequest() { + int fileClientMessageIndex = 71; + 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 = 72; + ClientMessage encoded = MapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLockCodec_decodeRequest() { + int fileClientMessageIndex = 73; + 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 = 74; + ClientMessage encoded = MapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 75; + 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 = 76; + ClientMessage encoded = MapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 77; + 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 = 78; + ClientMessage encoded = MapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 79; + 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 = 80; + ClientMessage encoded = MapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 81; + 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 = 82; + ClientMessage encoded = MapAddInterceptorCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 83; + 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 = 84; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 85; + 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 = 86; + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 87; + 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 = 88; + 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 = 89; + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 90; + 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 = 91; + 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 = 92; + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 93; + 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 = 94; + 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 = 95; + ClientMessage encoded = MapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 96; + 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 = 97; + 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 = 98; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 99; + 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 = 100; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() { + int fileClientMessageIndex = 101; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeMapPartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 102; + 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 = 103; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeRequest() { + int fileClientMessageIndex = 104; + 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 = 105; + ClientMessage encoded = MapGetEntryViewCodec.encodeResponse(null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeRequest() { + int fileClientMessageIndex = 106; + 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 = 107; + ClientMessage encoded = MapEvictCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEvictAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeResponse() { + int fileClientMessageIndex = 109; + ClientMessage encoded = MapEvictAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 110; + 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 = 111; + ClientMessage encoded = MapLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeRequest() { + int fileClientMessageIndex = 112; + 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 = 113; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 115; + ClientMessage encoded = MapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 116; + 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 = 117; + ClientMessage encoded = MapGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 119; + ClientMessage encoded = MapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage encoded = MapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 122; + 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 = 123; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 124; + 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 = 125; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 126; + 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 = 127; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeRequest() { + int fileClientMessageIndex = 128; + 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 = 129; + ClientMessage encoded = MapAddIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage encoded = MapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage encoded = MapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 134; + 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 = 135; + ClientMessage encoded = MapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapClearCodec_encodeResponse() { + int fileClientMessageIndex = 137; + ClientMessage encoded = MapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeRequest() { + int fileClientMessageIndex = 138; + 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 = 139; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 140; + 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 = 141; + ClientMessage encoded = MapSubmitToKeyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 142; + 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 = 143; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 144; + 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 = 145; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeRequest() { + int fileClientMessageIndex = 146; + 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 = 147; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 148; + 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 = 149; + ClientMessage encoded = MapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 150; + 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 = 151; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 152; + 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 = 153; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 154; + 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 = 155; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeResponse(aListOfDataToData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeRequest() { + int fileClientMessageIndex = 156; + 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 = 157; + ClientMessage encoded = MapFetchKeysCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 158; + 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 = 159; + ClientMessage encoded = MapFetchEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeRequest() { + int fileClientMessageIndex = 160; + 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 = 161; + ClientMessage encoded = MapAggregateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 162; + 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 = 163; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeRequest() { + int fileClientMessageIndex = 164; + 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 = 165; + ClientMessage encoded = MapProjectCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 166; + 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 = 167; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 168; + 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 = 169; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 170; + 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 = 171; + ClientMessage encoded = MapRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 172; + 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 = 173; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidationEvent() { + int fileClientMessageIndex = 174; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapInvalidationEvent(null, aUUID, aUUID, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 175; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapBatchInvalidationEvent(aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchWithQueryCodec_decodeRequest() { + int fileClientMessageIndex = 176; + 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 = 177; + ClientMessage encoded = MapFetchWithQueryCodec.encodeResponse(aListOfData, aListOfIntegerToInteger); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 178; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 179; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 180; + 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 = 181; + ClientMessage encoded = MapEventJournalReadCodec.encodeResponse(anInt, aListOfData, null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeRequest() { + int fileClientMessageIndex = 182; + 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 = 183; + ClientMessage encoded = MapSetTtlCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 184; + 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 = 185; + ClientMessage encoded = MapPutWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 186; + 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 = 187; + ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 188; + 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 = 189; + ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 190; + 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 = 191; + ClientMessage encoded = MapSetWithMaxIdleCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 192; + 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 = 193; + ClientMessage encoded = MultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 194; + 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 = 195; + ClientMessage encoded = MultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 196; + 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 = 197; + ClientMessage encoded = MultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 199; + ClientMessage encoded = MultiMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 201; + ClientMessage encoded = MultiMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage encoded = MultiMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 204; + 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 = 205; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 206; + 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 = 207; + ClientMessage encoded = MultiMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeRequest() { + int fileClientMessageIndex = 208; + 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 = 209; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage encoded = MultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 213; + ClientMessage encoded = MultiMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 214; + 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 = 215; + ClientMessage encoded = MultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 216; + 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 = 217; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 218; + 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 = 219; + 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 = 220; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 221; + 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 = 222; + 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 = 223; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapLockCodec_decodeRequest() { + int fileClientMessageIndex = 224; + 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 = 225; + ClientMessage encoded = MultiMapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 226; + 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 = 227; + ClientMessage encoded = MultiMapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 228; + 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 = 229; + ClientMessage encoded = MultiMapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 230; + 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 = 231; + ClientMessage encoded = MultiMapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 232; + 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 = 233; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 234; + 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 = 235; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 236; + 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 = 237; + ClientMessage encoded = MultiMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 238; + 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 = 239; + ClientMessage encoded = MultiMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 240; + 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 = 241; + ClientMessage encoded = QueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeRequest() { + int fileClientMessageIndex = 242; + 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 = 243; + ClientMessage encoded = QueuePutCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueSizeCodec_encodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage encoded = QueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 246; + 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 = 247; + ClientMessage encoded = QueueRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 248; + 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 = 249; + ClientMessage encoded = QueuePollCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueTakeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage encoded = QueueTakeCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueuePeekCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeResponse() { + int fileClientMessageIndex = 253; + ClientMessage encoded = QueuePeekCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage encoded = QueueIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueDrainToCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage encoded = QueueDrainToCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeRequest() { + int fileClientMessageIndex = 258; + 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 = 259; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeRequest() { + int fileClientMessageIndex = 260; + 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 = 261; + ClientMessage encoded = QueueContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 262; + 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 = 263; + ClientMessage encoded = QueueContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 264; + 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 = 265; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 266; + 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 = 267; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeResponse() { + int fileClientMessageIndex = 269; + ClientMessage encoded = QueueClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 270; + 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 = 271; + ClientMessage encoded = QueueAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 272; + 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 = 273; + ClientMessage encoded = QueueAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 274; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = QueueAddListenerCodec.encodeItemEvent(null, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 275; + 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 = 276; + ClientMessage encoded = QueueRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 277; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 278; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 279; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 280; + ClientMessage encoded = QueueIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeRequest() { + int fileClientMessageIndex = 281; + 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 = 282; + ClientMessage encoded = TopicPublishCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 283; + 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 = 284; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { + int fileClientMessageIndex = 285; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = TopicAddMessageListenerCodec.encodeTopicEvent(aData, aLong, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 286; + 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 = 287; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeRequest() { + int fileClientMessageIndex = 288; + 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 = 289; + ClientMessage encoded = TopicPublishAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 290; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListSizeCodec_encodeResponse() { + int fileClientMessageIndex = 291; + ClientMessage encoded = ListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeRequest() { + int fileClientMessageIndex = 292; + 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 = 293; + ClientMessage encoded = ListContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 294; + 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 = 295; + ClientMessage encoded = ListContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeRequest() { + int fileClientMessageIndex = 296; + 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 = 297; + ClientMessage encoded = ListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 298; + 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 = 299; + ClientMessage encoded = ListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 300; + 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 = 301; + ClientMessage encoded = ListAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 302; + 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 = 303; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 304; + 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 = 305; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeResponse() { + int fileClientMessageIndex = 307; + ClientMessage encoded = ListClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage encoded = ListGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 310; + 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 = 311; + ClientMessage encoded = ListAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 312; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ListAddListenerCodec.encodeItemEvent(null, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 313; + 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 = 314; + ClientMessage encoded = ListRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 315; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 316; + ClientMessage encoded = ListIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 317; + 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 = 318; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeRequest() { + int fileClientMessageIndex = 319; + 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 = 320; + ClientMessage encoded = ListGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeRequest() { + int fileClientMessageIndex = 321; + 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 = 322; + ClientMessage encoded = ListSetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 323; + 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 = 324; + ClientMessage encoded = ListAddWithIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 325; + 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 = 326; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 327; + 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 = 328; + ClientMessage encoded = ListLastIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 329; + 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 = 330; + ClientMessage encoded = ListIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeRequest() { + int fileClientMessageIndex = 331; + 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 = 332; + ClientMessage encoded = ListSubCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 334; + ClientMessage encoded = ListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 335; + 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 = 336; + ClientMessage encoded = ListListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage encoded = SetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeRequest() { + int fileClientMessageIndex = 339; + 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 = 340; + ClientMessage encoded = SetContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 341; + 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 = 342; + ClientMessage encoded = SetContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeRequest() { + int fileClientMessageIndex = 343; + 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 = 344; + ClientMessage encoded = SetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 345; + 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 = 346; + ClientMessage encoded = SetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 347; + 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 = 348; + ClientMessage encoded = SetAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 349; + 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 = 350; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 351; + 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 = 352; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeResponse() { + int fileClientMessageIndex = 354; + ClientMessage encoded = SetClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage encoded = SetGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 357; + 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 = 358; + ClientMessage encoded = SetAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 359; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = SetAddListenerCodec.encodeItemEvent(null, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 360; + 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 = 361; + ClientMessage encoded = SetRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 362; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 363; + ClientMessage encoded = SetIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockLockCodec_decodeRequest() { + int fileClientMessageIndex = 364; + 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 = 365; + ClientMessage encoded = FencedLockLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 366; + 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 = 367; + ClientMessage encoded = FencedLockTryLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 368; + 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 = 369; + ClientMessage encoded = FencedLockUnlockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { + int fileClientMessageIndex = 370; + 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 = 371; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeResponse(aLong, anInt, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 372; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 373; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 376; + 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 = 377; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { + int fileClientMessageIndex = 378; + 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 = 379; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 380; + 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 = 381; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 382; + 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 = 383; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeRequest() { + int fileClientMessageIndex = 384; + 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 = 385; + ClientMessage encoded = AtomicLongApplyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeRequest() { + int fileClientMessageIndex = 386; + 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 = 387; + ClientMessage encoded = AtomicLongAlterCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeRequest() { + int fileClientMessageIndex = 388; + 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 = 389; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 390; + 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 = 391; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeRequest() { + int fileClientMessageIndex = 392; + 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 = 393; + ClientMessage encoded = AtomicLongGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeRequest() { + int fileClientMessageIndex = 394; + 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 = 395; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 396; + 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 = 397; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefApplyCodec_decodeRequest() { + int fileClientMessageIndex = 398; + 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 = 399; + ClientMessage encoded = AtomicRefApplyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 400; + 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 = 401; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeRequest() { + int fileClientMessageIndex = 402; + 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 = 403; + ClientMessage encoded = AtomicRefContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeRequest() { + int fileClientMessageIndex = 404; + 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 = 405; + ClientMessage encoded = AtomicRefGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeRequest() { + int fileClientMessageIndex = 406; + 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 = 407; + ClientMessage encoded = AtomicRefSetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeRequest() { + int fileClientMessageIndex = 408; + 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 = 409; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeRequest() { + int fileClientMessageIndex = 410; + 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 = 411; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeRequest() { + int fileClientMessageIndex = 412; + 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 = 413; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeRequest() { + int fileClientMessageIndex = 414; + 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 = 415; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeRequest() { + int fileClientMessageIndex = 416; + 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 = 417; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeRequest() { + int fileClientMessageIndex = 418; + 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 = 419; + ClientMessage encoded = SemaphoreInitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAcquireCodec_decodeRequest() { + int fileClientMessageIndex = 420; + 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 = 421; + ClientMessage encoded = SemaphoreAcquireCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreReleaseCodec_decodeRequest() { + int fileClientMessageIndex = 422; + 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 = 423; + ClientMessage encoded = SemaphoreReleaseCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreDrainCodec_decodeRequest() { + int fileClientMessageIndex = 424; + 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 = 425; + ClientMessage encoded = SemaphoreDrainCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreChangeCodec_decodeRequest() { + int fileClientMessageIndex = 426; + 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 = 427; + ClientMessage encoded = SemaphoreChangeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { + int fileClientMessageIndex = 428; + 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 = 429; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SemaphoreGetSemaphoreTypeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 432; + 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 = 433; + ClientMessage encoded = ReplicatedMapPutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 438; + 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 = 439; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 440; + 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 = 441; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 442; + 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 = 443; + ClientMessage encoded = ReplicatedMapGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 444; + 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 = 445; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 446; + 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 = 447; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 449; + ClientMessage encoded = ReplicatedMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 450; + 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 = 451; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 452; + 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 = 453; + 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 = 454; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 455; + 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 = 456; + 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 = 457; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 458; + 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 = 459; + 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 = 460; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 461; + 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 = 462; + 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 = 463; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 464; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 465; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 468; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 469; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 470; + 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 = 471; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 472; + 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 = 473; + 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 = 474; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 475; + 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 = 476; + ClientMessage encoded = TransactionalMapGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { + int fileClientMessageIndex = 477; + 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 = 478; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 479; + 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 = 480; + ClientMessage encoded = TransactionalMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 481; + 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 = 482; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 483; + 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 = 484; + ClientMessage encoded = TransactionalMapPutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSetCodec_decodeRequest() { + int fileClientMessageIndex = 485; + 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 = 486; + ClientMessage encoded = TransactionalMapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 487; + 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 = 488; + ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 489; + 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 = 490; + ClientMessage encoded = TransactionalMapReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 491; + 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 = 492; + ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 493; + 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 = 494; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 495; + 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 = 496; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 497; + 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 = 498; + ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 499; + 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 = 500; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 501; + 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 = 502; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 503; + 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 = 504; + ClientMessage encoded = TransactionalMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 505; + 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 = 506; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 507; + 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 = 508; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 509; + 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 = 510; + ClientMessage encoded = TransactionalMultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 511; + 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 = 512; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 513; + 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 = 514; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 515; + 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 = 516; + ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 517; + 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 = 518; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 519; + 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 = 520; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeRequest() { + int fileClientMessageIndex = 521; + 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 = 522; + ClientMessage encoded = TransactionalSetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 523; + 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 = 524; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 525; + 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 = 526; + ClientMessage encoded = TransactionalSetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeRequest() { + int fileClientMessageIndex = 527; + 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 = 528; + ClientMessage encoded = TransactionalListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 529; + 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 = 530; + ClientMessage encoded = TransactionalListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 531; + 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 = 532; + ClientMessage encoded = TransactionalListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 533; + 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 = 534; + ClientMessage encoded = TransactionalQueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 535; + 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 = 536; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 537; + 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 = 538; + ClientMessage encoded = TransactionalQueuePollCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 539; + 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 = 540; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 541; + 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 = 542; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 543; + 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 = 544; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { + int fileClientMessageIndex = 545; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddEntryListenerCodec.encodeCacheEvent(anInt, aListOfCacheEventData, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeRequest() { + int fileClientMessageIndex = 546; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheClearCodec_encodeResponse() { + int fileClientMessageIndex = 547; + ClientMessage encoded = CacheClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 548; + 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 = 549; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 550; + 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 = 551; + ClientMessage encoded = CacheRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 552; + 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 = 553; + ClientMessage encoded = CacheContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeRequest() { + int fileClientMessageIndex = 554; + 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 = 555; + ClientMessage encoded = CacheCreateConfigCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheDestroyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeResponse() { + int fileClientMessageIndex = 557; + ClientMessage encoded = CacheDestroyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEntryProcessorCodec_decodeRequest() { + int fileClientMessageIndex = 558; + 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 = 559; + ClientMessage encoded = CacheEntryProcessorCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 560; + 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 = 561; + ClientMessage encoded = CacheGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 562; + 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 = 563; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 564; + 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 = 565; + ClientMessage encoded = CacheGetAndReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 566; + 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 = 567; + ClientMessage encoded = CacheGetConfigCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeRequest() { + int fileClientMessageIndex = 568; + 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 = 569; + ClientMessage encoded = CacheGetCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeRequest() { + int fileClientMessageIndex = 570; + 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 = 571; + ClientMessage encoded = CacheIterateCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeRequest() { + int fileClientMessageIndex = 572; + 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 = 573; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 574; + 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 = 575; + ClientMessage encoded = CacheLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeRequest() { + int fileClientMessageIndex = 576; + 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 = 577; + ClientMessage encoded = CacheManagementConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 578; + 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 = 579; + ClientMessage encoded = CachePutIfAbsentCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutCodec_decodeRequest() { + int fileClientMessageIndex = 580; + 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 = 581; + ClientMessage encoded = CachePutCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 582; + 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 = 583; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 584; + 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 = 585; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 586; + 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 = 587; + ClientMessage encoded = CacheRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 588; + 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 = 589; + ClientMessage encoded = CacheReplaceCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage encoded = CacheSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 592; + 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 = 593; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEvent() { + int fileClientMessageIndex = 594; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeCachePartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 595; + 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 = 596; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeRequest() { + int fileClientMessageIndex = 597; + 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 = 598; + ClientMessage encoded = CachePutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 599; + 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 = 600; + ClientMessage encoded = CacheIterateEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 601; + 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 = 602; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidationEvent() { + int fileClientMessageIndex = 603; + 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 = 604; + 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 = 605; + 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 = 606; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 607; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 608; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 609; + 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 = 610; + ClientMessage encoded = CacheEventJournalReadCodec.encodeResponse(anInt, aListOfData, null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeRequest() { + int fileClientMessageIndex = 611; + 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 = 612; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeRequest() { + int fileClientMessageIndex = 613; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anXid, XATransactionClearRemoteCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeResponse() { + int fileClientMessageIndex = 614; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeRequest() { + int fileClientMessageIndex = 615; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeResponse(aListOfXids); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeRequest() { + int fileClientMessageIndex = 617; + 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 = 618; + ClientMessage encoded = XATransactionFinalizeCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 619; + 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 = 620; + ClientMessage encoded = XATransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 621; + 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 = 622; + ClientMessage encoded = XATransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionPrepareCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeResponse() { + int fileClientMessageIndex = 624; + ClientMessage encoded = XATransactionPrepareCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 625; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionRollbackCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionRollbackCodec_encodeResponse() { + int fileClientMessageIndex = 626; + ClientMessage encoded = XATransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 627; + 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 = 628; + ClientMessage encoded = TransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 629; + 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 = 630; + ClientMessage encoded = TransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 631; + 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 = 632; + ClientMessage encoded = TransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { + int fileClientMessageIndex = 633; + 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 = 634; + ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { + int fileClientMessageIndex = 635; + 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 = 636; + ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { + int fileClientMessageIndex = 637; + 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 = 638; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 639; + 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 = 640; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { + int fileClientMessageIndex = 641; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheSingleEvent(aQueryCacheEventData); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { + int fileClientMessageIndex = 642; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheBatchEvent(aListOfQueryCacheEventData, aString, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { + int fileClientMessageIndex = 643; + 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 = 644; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { + int fileClientMessageIndex = 645; + 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 = 646; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage encoded = RingbufferSizeCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferTailSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 651; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferHeadSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 652; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage encoded = RingbufferCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeRequest() { + int fileClientMessageIndex = 657; + 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 = 658; + ClientMessage encoded = RingbufferAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeRequest() { + int fileClientMessageIndex = 659; + 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 = 660; + ClientMessage encoded = RingbufferReadOneCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 661; + 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 = 662; + ClientMessage encoded = RingbufferAddAllCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadManyCodec_decodeRequest() { + int fileClientMessageIndex = 663; + 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 = 664; + ClientMessage encoded = RingbufferReadManyCodec.encodeResponse(anInt, aListOfData, null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 665; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 666; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 669; + 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 = 670; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { + int fileClientMessageIndex = 671; + 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 = 672; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 673; + 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 = 674; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 675; + 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 = 676; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeRequest() { + int fileClientMessageIndex = 677; + 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 = 678; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CardinalityEstimatorEstimateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 681; + 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 = 682; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 683; + 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 = 684; + ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 685; + 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 = 686; + ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ScheduledExecutorGetAllScheduledFuturesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { + int fileClientMessageIndex = 688; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeResponse(aListOfScheduledTaskHandler); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 689; + 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 = 690; + 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 = 691; + 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 = 692; + 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 = 693; + 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 = 694; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 695; + 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 = 696; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 697; + 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 = 698; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 699; + 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 = 700; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 701; + 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 = 702; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 703; + 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 = 704; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 705; + 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 = 706; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 707; + 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 = 708; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 709; + 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 = 710; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 711; + 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 = 712; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 713; + 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 = 714; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 715; + 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 = 716; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 717; + 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 = 718; + ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { + int fileClientMessageIndex = 719; + 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 = 720; + ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 721; + 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 = 722; + ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_decodeRequest() { + int fileClientMessageIndex = 723; + 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 = 724; + ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 725; + 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 = 726; + ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 727; + 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 = 728; + ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 729; + 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 = 730; + ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 731; + 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 = 732; + ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 733; + 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 = 734; + ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 735; + 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)); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 736; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { + int fileClientMessageIndex = 737; + 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 = 738; + ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 739; + 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)); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 740; + ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 741; + 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 = 742; + ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { + int fileClientMessageIndex = 743; + 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)); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { + int fileClientMessageIndex = 744; + ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 745; + 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 = 746; + ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { + int fileClientMessageIndex = 747; + 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 = 748; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { + int fileClientMessageIndex = 749; + 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 = 750; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeResponse(aLong, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeRequest() { + int fileClientMessageIndex = 751; + 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 = 752; + ClientMessage encoded = PNCounterGetCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterAddCodec_decodeRequest() { + int fileClientMessageIndex = 753; + 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 = 754; + ClientMessage encoded = PNCounterAddCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeRequest() { + int fileClientMessageIndex = 755; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, PNCounterGetConfiguredReplicaCountCodec.decodeRequest(fromFile))); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { + int fileClientMessageIndex = 756; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CPGroupCreateCPGroupCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeResponse() { + int fileClientMessageIndex = 758; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeResponse(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { + int fileClientMessageIndex = 759; + 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 = 760; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeRequest() { + int fileClientMessageIndex = 761; + 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 = 762; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeResponse(aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeRequest() { + int fileClientMessageIndex = 763; + 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 = 764; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { + int fileClientMessageIndex = 765; + 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 = 766; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPSessionGenerateThreadIdCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeRequest() { + int fileClientMessageIndex = 769; + 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 = 770; + ClientMessage encoded = MCReadMetricsCodec.encodeResponse(aListOfLongToByteArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeRequest() { + int fileClientMessageIndex = 771; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MCChangeClusterStateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCChangeClusterStateCodec_encodeResponse() { + int fileClientMessageIndex = 772; + ClientMessage encoded = MCChangeClusterStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMapConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 774; + ClientMessage encoded = MCGetMapConfigCodec.encodeResponse(anInt, anInt, anInt, anInt, anInt, anInt, anInt, aBoolean, anInt, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 775; + 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 = 776; + ClientMessage encoded = MCUpdateMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeRequest() { + int fileClientMessageIndex = 777; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeResponse() { + int fileClientMessageIndex = 778; + ClientMessage encoded = MCGetMemberConfigCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeRequest() { + int fileClientMessageIndex = 779; + } + + @Test + public void test_MCRunGcCodec_encodeResponse() { + int fileClientMessageIndex = 780; + ClientMessage encoded = MCRunGcCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCGetThreadDumpCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetThreadDumpCodec_encodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage encoded = MCGetThreadDumpCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeRequest() { + int fileClientMessageIndex = 783; + } + + @Test + public void test_MCShutdownMemberCodec_encodeResponse() { + int fileClientMessageIndex = 784; + ClientMessage encoded = MCShutdownMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeRequest() { + int fileClientMessageIndex = 785; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeResponse() { + int fileClientMessageIndex = 786; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeRequest() { + int fileClientMessageIndex = 787; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeResponse() { + int fileClientMessageIndex = 788; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeResponse(aListOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeRequest() { + int fileClientMessageIndex = 789; + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 791; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCMatchMCConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeResponse() { + int fileClientMessageIndex = 792; + ClientMessage encoded = MCMatchMCConfigCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 793; + 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 = 794; + ClientMessage encoded = MCApplyMCConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 795; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 796; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeResponse(aByte, aString, null, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeRequest() { + int fileClientMessageIndex = 797; + } + + @Test + public void test_MCShutdownClusterCodec_encodeResponse() { + int fileClientMessageIndex = 798; + ClientMessage encoded = MCShutdownClusterCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeRequest() { + int fileClientMessageIndex = 799; + 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 = 800; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeRequest() { + int fileClientMessageIndex = 801; + 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 = 802; + ClientMessage encoded = MCRunScriptCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeRequest() { + int fileClientMessageIndex = 803; + 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 = 804; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeRequest() { + int fileClientMessageIndex = 805; + 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 = 806; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeRequest() { + int fileClientMessageIndex = 807; + 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 = 808; + ClientMessage encoded = MCClearWanQueuesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { + int fileClientMessageIndex = 809; + 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 = 810; + ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeResponse(aListOfStrings, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeRequest() { + int fileClientMessageIndex = 811; + 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 = 812; + ClientMessage encoded = MCWanSyncMapCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeRequest() { + int fileClientMessageIndex = 813; + 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 = 814; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeResponse(null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeRequest() { + int fileClientMessageIndex = 815; + } + + @Test + public void test_MCPollMCEventsCodec_encodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage encoded = MCPollMCEventsCodec.encodeResponse(aListOfMCEvents); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeRequest() { + int fileClientMessageIndex = 817; + } + + @Test + public void test_MCGetCPMembersCodec_encodeResponse() { + int fileClientMessageIndex = 818; + ClientMessage encoded = MCGetCPMembersCodec.encodeResponse(aListOfUUIDToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 819; + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 820; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCRemoveCPMemberCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 822; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeRequest() { + int fileClientMessageIndex = 823; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeResponse() { + int fileClientMessageIndex = 824; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeRequest() { + int fileClientMessageIndex = 825; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeRequest() { + int fileClientMessageIndex = 827; + } + + @Test + public void test_MCTriggerForceStartCodec_encodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage encoded = MCTriggerForceStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 829; + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 830; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 831; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 832; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeRequest() { + int fileClientMessageIndex = 833; + 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)); + } + + @Test + public void test_SqlExecuteCodec_encodeResponse() { + int fileClientMessageIndex = 834; + ClientMessage encoded = SqlExecuteCodec.encodeResponse(null, null, null, aBoolean, aLong, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeRequest() { + int fileClientMessageIndex = 835; + 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 = 836; + ClientMessage encoded = SqlFetchCodec.encodeResponse(null, aBoolean, null); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeRequest() { + int fileClientMessageIndex = 837; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anSqlQueryId, SqlCloseCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SqlCloseCodec_encodeResponse() { + int fileClientMessageIndex = 838; + ClientMessage encoded = SqlCloseCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 839; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 840; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEvent() { + int fileClientMessageIndex = 841; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeMembershipEventEvent(aCpMember, aByte); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 842; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 843; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 844; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 845; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailabilityEventEvent() { + int fileClientMessageIndex = 846; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeGroupAvailabilityEventEvent(aRaftGroupId, aListOfCpMembers, aListOfCpMembers); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 847; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeResponse(aBoolean); + 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_1.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_1.java index c0c48a6bf0df0..d0167f61805b8 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_1.java +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_1.java @@ -358,55 +358,9 @@ public void test_ClientTriggerPartitionAssignmentCodec_encodeResponse() { 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_MapPutCodec_decodeRequest() { - int fileClientMessageIndex = 43; + int fileClientMessageIndex = 37; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutCodec.RequestParameters parameters = MapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -418,7 +372,7 @@ public void test_MapPutCodec_decodeRequest() { @Test public void test_MapPutCodec_encodeResponse() { - int fileClientMessageIndex = 44; + int fileClientMessageIndex = 38; ClientMessage encoded = MapPutCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -426,7 +380,7 @@ public void test_MapPutCodec_encodeResponse() { @Test public void test_MapGetCodec_decodeRequest() { - int fileClientMessageIndex = 45; + int fileClientMessageIndex = 39; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetCodec.RequestParameters parameters = MapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -436,7 +390,7 @@ public void test_MapGetCodec_decodeRequest() { @Test public void test_MapGetCodec_encodeResponse() { - int fileClientMessageIndex = 46; + int fileClientMessageIndex = 40; ClientMessage encoded = MapGetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -444,7 +398,7 @@ public void test_MapGetCodec_encodeResponse() { @Test public void test_MapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 47; + int fileClientMessageIndex = 41; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveCodec.RequestParameters parameters = MapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -454,7 +408,7 @@ public void test_MapRemoveCodec_decodeRequest() { @Test public void test_MapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 48; + int fileClientMessageIndex = 42; ClientMessage encoded = MapRemoveCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -462,7 +416,7 @@ public void test_MapRemoveCodec_encodeResponse() { @Test public void test_MapReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 49; + int fileClientMessageIndex = 43; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapReplaceCodec.RequestParameters parameters = MapReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -473,7 +427,7 @@ public void test_MapReplaceCodec_decodeRequest() { @Test public void test_MapReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 50; + int fileClientMessageIndex = 44; ClientMessage encoded = MapReplaceCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -481,7 +435,7 @@ public void test_MapReplaceCodec_encodeResponse() { @Test public void test_MapReplaceIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 51; + int fileClientMessageIndex = 45; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapReplaceIfSameCodec.RequestParameters parameters = MapReplaceIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -493,7 +447,7 @@ public void test_MapReplaceIfSameCodec_decodeRequest() { @Test public void test_MapReplaceIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 52; + int fileClientMessageIndex = 46; ClientMessage encoded = MapReplaceIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -501,7 +455,7 @@ public void test_MapReplaceIfSameCodec_encodeResponse() { @Test public void test_MapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 53; + int fileClientMessageIndex = 47; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapContainsKeyCodec.RequestParameters parameters = MapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -511,7 +465,7 @@ public void test_MapContainsKeyCodec_decodeRequest() { @Test public void test_MapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 54; + int fileClientMessageIndex = 48; ClientMessage encoded = MapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -519,7 +473,7 @@ public void test_MapContainsKeyCodec_encodeResponse() { @Test public void test_MapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 55; + int fileClientMessageIndex = 49; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapContainsValueCodec.RequestParameters parameters = MapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -528,7 +482,7 @@ public void test_MapContainsValueCodec_decodeRequest() { @Test public void test_MapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 56; + int fileClientMessageIndex = 50; ClientMessage encoded = MapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -536,7 +490,7 @@ public void test_MapContainsValueCodec_encodeResponse() { @Test public void test_MapRemoveIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 57; + int fileClientMessageIndex = 51; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveIfSameCodec.RequestParameters parameters = MapRemoveIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -547,7 +501,7 @@ public void test_MapRemoveIfSameCodec_decodeRequest() { @Test public void test_MapRemoveIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 58; + int fileClientMessageIndex = 52; ClientMessage encoded = MapRemoveIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -555,7 +509,7 @@ public void test_MapRemoveIfSameCodec_encodeResponse() { @Test public void test_MapDeleteCodec_decodeRequest() { - int fileClientMessageIndex = 59; + int fileClientMessageIndex = 53; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapDeleteCodec.RequestParameters parameters = MapDeleteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -565,7 +519,7 @@ public void test_MapDeleteCodec_decodeRequest() { @Test public void test_MapDeleteCodec_encodeResponse() { - int fileClientMessageIndex = 60; + int fileClientMessageIndex = 54; ClientMessage encoded = MapDeleteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -573,14 +527,14 @@ public void test_MapDeleteCodec_encodeResponse() { @Test public void test_MapFlushCodec_decodeRequest() { - int fileClientMessageIndex = 61; + int fileClientMessageIndex = 55; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapFlushCodec.decodeRequest(fromFile))); } @Test public void test_MapFlushCodec_encodeResponse() { - int fileClientMessageIndex = 62; + int fileClientMessageIndex = 56; ClientMessage encoded = MapFlushCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -588,7 +542,7 @@ public void test_MapFlushCodec_encodeResponse() { @Test public void test_MapTryRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 63; + int fileClientMessageIndex = 57; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapTryRemoveCodec.RequestParameters parameters = MapTryRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -599,7 +553,7 @@ public void test_MapTryRemoveCodec_decodeRequest() { @Test public void test_MapTryRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 64; + int fileClientMessageIndex = 58; ClientMessage encoded = MapTryRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -607,7 +561,7 @@ public void test_MapTryRemoveCodec_encodeResponse() { @Test public void test_MapTryPutCodec_decodeRequest() { - int fileClientMessageIndex = 65; + int fileClientMessageIndex = 59; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapTryPutCodec.RequestParameters parameters = MapTryPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -619,7 +573,7 @@ public void test_MapTryPutCodec_decodeRequest() { @Test public void test_MapTryPutCodec_encodeResponse() { - int fileClientMessageIndex = 66; + int fileClientMessageIndex = 60; ClientMessage encoded = MapTryPutCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -627,7 +581,7 @@ public void test_MapTryPutCodec_encodeResponse() { @Test public void test_MapPutTransientCodec_decodeRequest() { - int fileClientMessageIndex = 67; + int fileClientMessageIndex = 61; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutTransientCodec.RequestParameters parameters = MapPutTransientCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -639,7 +593,7 @@ public void test_MapPutTransientCodec_decodeRequest() { @Test public void test_MapPutTransientCodec_encodeResponse() { - int fileClientMessageIndex = 68; + int fileClientMessageIndex = 62; ClientMessage encoded = MapPutTransientCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -647,7 +601,7 @@ public void test_MapPutTransientCodec_encodeResponse() { @Test public void test_MapPutIfAbsentCodec_decodeRequest() { - int fileClientMessageIndex = 69; + int fileClientMessageIndex = 63; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutIfAbsentCodec.RequestParameters parameters = MapPutIfAbsentCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -659,7 +613,7 @@ public void test_MapPutIfAbsentCodec_decodeRequest() { @Test public void test_MapPutIfAbsentCodec_encodeResponse() { - int fileClientMessageIndex = 70; + int fileClientMessageIndex = 64; ClientMessage encoded = MapPutIfAbsentCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -667,7 +621,7 @@ public void test_MapPutIfAbsentCodec_encodeResponse() { @Test public void test_MapSetCodec_decodeRequest() { - int fileClientMessageIndex = 71; + int fileClientMessageIndex = 65; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSetCodec.RequestParameters parameters = MapSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -679,7 +633,7 @@ public void test_MapSetCodec_decodeRequest() { @Test public void test_MapSetCodec_encodeResponse() { - int fileClientMessageIndex = 72; + int fileClientMessageIndex = 66; ClientMessage encoded = MapSetCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -687,7 +641,7 @@ public void test_MapSetCodec_encodeResponse() { @Test public void test_MapLockCodec_decodeRequest() { - int fileClientMessageIndex = 73; + int fileClientMessageIndex = 67; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapLockCodec.RequestParameters parameters = MapLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -699,7 +653,7 @@ public void test_MapLockCodec_decodeRequest() { @Test public void test_MapLockCodec_encodeResponse() { - int fileClientMessageIndex = 74; + int fileClientMessageIndex = 68; ClientMessage encoded = MapLockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -707,7 +661,7 @@ public void test_MapLockCodec_encodeResponse() { @Test public void test_MapTryLockCodec_decodeRequest() { - int fileClientMessageIndex = 75; + int fileClientMessageIndex = 69; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapTryLockCodec.RequestParameters parameters = MapTryLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -720,7 +674,7 @@ public void test_MapTryLockCodec_decodeRequest() { @Test public void test_MapTryLockCodec_encodeResponse() { - int fileClientMessageIndex = 76; + int fileClientMessageIndex = 70; ClientMessage encoded = MapTryLockCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -728,7 +682,7 @@ public void test_MapTryLockCodec_encodeResponse() { @Test public void test_MapIsLockedCodec_decodeRequest() { - int fileClientMessageIndex = 77; + int fileClientMessageIndex = 71; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapIsLockedCodec.RequestParameters parameters = MapIsLockedCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -737,7 +691,7 @@ public void test_MapIsLockedCodec_decodeRequest() { @Test public void test_MapIsLockedCodec_encodeResponse() { - int fileClientMessageIndex = 78; + int fileClientMessageIndex = 72; ClientMessage encoded = MapIsLockedCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -745,7 +699,7 @@ public void test_MapIsLockedCodec_encodeResponse() { @Test public void test_MapUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 79; + int fileClientMessageIndex = 73; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapUnlockCodec.RequestParameters parameters = MapUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -756,7 +710,7 @@ public void test_MapUnlockCodec_decodeRequest() { @Test public void test_MapUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 80; + int fileClientMessageIndex = 74; ClientMessage encoded = MapUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -764,7 +718,7 @@ public void test_MapUnlockCodec_encodeResponse() { @Test public void test_MapAddInterceptorCodec_decodeRequest() { - int fileClientMessageIndex = 81; + int fileClientMessageIndex = 75; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddInterceptorCodec.RequestParameters parameters = MapAddInterceptorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -773,7 +727,7 @@ public void test_MapAddInterceptorCodec_decodeRequest() { @Test public void test_MapAddInterceptorCodec_encodeResponse() { - int fileClientMessageIndex = 82; + int fileClientMessageIndex = 76; ClientMessage encoded = MapAddInterceptorCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -781,7 +735,7 @@ public void test_MapAddInterceptorCodec_encodeResponse() { @Test public void test_MapRemoveInterceptorCodec_decodeRequest() { - int fileClientMessageIndex = 83; + int fileClientMessageIndex = 77; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveInterceptorCodec.RequestParameters parameters = MapRemoveInterceptorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -790,7 +744,7 @@ public void test_MapRemoveInterceptorCodec_decodeRequest() { @Test public void test_MapRemoveInterceptorCodec_encodeResponse() { - int fileClientMessageIndex = 84; + int fileClientMessageIndex = 78; ClientMessage encoded = MapRemoveInterceptorCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -798,7 +752,7 @@ public void test_MapRemoveInterceptorCodec_encodeResponse() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 85; + int fileClientMessageIndex = 79; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -811,7 +765,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 86; + int fileClientMessageIndex = 80; ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -819,7 +773,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { @Test public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 87; + int fileClientMessageIndex = 81; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -827,7 +781,7 @@ public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { @Test public void test_MapAddEntryListenerWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 88; + int fileClientMessageIndex = 82; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerWithPredicateCodec.RequestParameters parameters = MapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -839,7 +793,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_decodeRequest() { @Test public void test_MapAddEntryListenerWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 89; + int fileClientMessageIndex = 83; ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -847,7 +801,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_encodeResponse() { @Test public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 90; + int fileClientMessageIndex = 84; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -855,7 +809,7 @@ public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { @Test public void test_MapAddEntryListenerToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 91; + int fileClientMessageIndex = 85; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerToKeyCodec.RequestParameters parameters = MapAddEntryListenerToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -867,7 +821,7 @@ public void test_MapAddEntryListenerToKeyCodec_decodeRequest() { @Test public void test_MapAddEntryListenerToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 92; + int fileClientMessageIndex = 86; ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -875,7 +829,7 @@ public void test_MapAddEntryListenerToKeyCodec_encodeResponse() { @Test public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { - int fileClientMessageIndex = 93; + int fileClientMessageIndex = 87; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -883,7 +837,7 @@ public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { @Test public void test_MapAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 94; + int fileClientMessageIndex = 88; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddEntryListenerCodec.RequestParameters parameters = MapAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -894,7 +848,7 @@ public void test_MapAddEntryListenerCodec_decodeRequest() { @Test public void test_MapAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 95; + int fileClientMessageIndex = 89; ClientMessage encoded = MapAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -902,7 +856,7 @@ public void test_MapAddEntryListenerCodec_encodeResponse() { @Test public void test_MapAddEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 96; + int fileClientMessageIndex = 90; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -910,7 +864,7 @@ public void test_MapAddEntryListenerCodec_encodeEntryEvent() { @Test public void test_MapRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 97; + int fileClientMessageIndex = 91; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveEntryListenerCodec.RequestParameters parameters = MapRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -919,7 +873,7 @@ public void test_MapRemoveEntryListenerCodec_decodeRequest() { @Test public void test_MapRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 98; + int fileClientMessageIndex = 92; ClientMessage encoded = MapRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -927,7 +881,7 @@ public void test_MapRemoveEntryListenerCodec_encodeResponse() { @Test public void test_MapAddPartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 99; + int fileClientMessageIndex = 93; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddPartitionLostListenerCodec.RequestParameters parameters = MapAddPartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -936,7 +890,7 @@ public void test_MapAddPartitionLostListenerCodec_decodeRequest() { @Test public void test_MapAddPartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 100; + int fileClientMessageIndex = 94; ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -944,7 +898,7 @@ public void test_MapAddPartitionLostListenerCodec_encodeResponse() { @Test public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() { - int fileClientMessageIndex = 101; + int fileClientMessageIndex = 95; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeMapPartitionLostEvent(anInt, aUUID); compareClientMessages(fromFile, encoded); @@ -952,7 +906,7 @@ public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() @Test public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 102; + int fileClientMessageIndex = 96; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemovePartitionLostListenerCodec.RequestParameters parameters = MapRemovePartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -961,7 +915,7 @@ public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { @Test public void test_MapRemovePartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 103; + int fileClientMessageIndex = 97; ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -969,7 +923,7 @@ public void test_MapRemovePartitionLostListenerCodec_encodeResponse() { @Test public void test_MapGetEntryViewCodec_decodeRequest() { - int fileClientMessageIndex = 104; + int fileClientMessageIndex = 98; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetEntryViewCodec.RequestParameters parameters = MapGetEntryViewCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -979,7 +933,7 @@ public void test_MapGetEntryViewCodec_decodeRequest() { @Test public void test_MapGetEntryViewCodec_encodeResponse() { - int fileClientMessageIndex = 105; + int fileClientMessageIndex = 99; ClientMessage encoded = MapGetEntryViewCodec.encodeResponse(aSimpleEntryView, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -987,7 +941,7 @@ public void test_MapGetEntryViewCodec_encodeResponse() { @Test public void test_MapEvictCodec_decodeRequest() { - int fileClientMessageIndex = 106; + int fileClientMessageIndex = 100; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEvictCodec.RequestParameters parameters = MapEvictCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -997,7 +951,7 @@ public void test_MapEvictCodec_decodeRequest() { @Test public void test_MapEvictCodec_encodeResponse() { - int fileClientMessageIndex = 107; + int fileClientMessageIndex = 101; ClientMessage encoded = MapEvictCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1005,14 +959,14 @@ public void test_MapEvictCodec_encodeResponse() { @Test public void test_MapEvictAllCodec_decodeRequest() { - int fileClientMessageIndex = 108; + int fileClientMessageIndex = 102; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapEvictAllCodec.decodeRequest(fromFile))); } @Test public void test_MapEvictAllCodec_encodeResponse() { - int fileClientMessageIndex = 109; + int fileClientMessageIndex = 103; ClientMessage encoded = MapEvictAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1020,7 +974,7 @@ public void test_MapEvictAllCodec_encodeResponse() { @Test public void test_MapLoadAllCodec_decodeRequest() { - int fileClientMessageIndex = 110; + int fileClientMessageIndex = 104; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapLoadAllCodec.RequestParameters parameters = MapLoadAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1029,7 +983,7 @@ public void test_MapLoadAllCodec_decodeRequest() { @Test public void test_MapLoadAllCodec_encodeResponse() { - int fileClientMessageIndex = 111; + int fileClientMessageIndex = 105; ClientMessage encoded = MapLoadAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1037,7 +991,7 @@ public void test_MapLoadAllCodec_encodeResponse() { @Test public void test_MapLoadGivenKeysCodec_decodeRequest() { - int fileClientMessageIndex = 112; + int fileClientMessageIndex = 106; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapLoadGivenKeysCodec.RequestParameters parameters = MapLoadGivenKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1047,7 +1001,7 @@ public void test_MapLoadGivenKeysCodec_decodeRequest() { @Test public void test_MapLoadGivenKeysCodec_encodeResponse() { - int fileClientMessageIndex = 113; + int fileClientMessageIndex = 107; ClientMessage encoded = MapLoadGivenKeysCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1055,14 +1009,14 @@ public void test_MapLoadGivenKeysCodec_encodeResponse() { @Test public void test_MapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 114; + int fileClientMessageIndex = 108; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapKeySetCodec.decodeRequest(fromFile))); } @Test public void test_MapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 115; + int fileClientMessageIndex = 109; ClientMessage encoded = MapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1070,7 +1024,7 @@ public void test_MapKeySetCodec_encodeResponse() { @Test public void test_MapGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 116; + int fileClientMessageIndex = 110; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapGetAllCodec.RequestParameters parameters = MapGetAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1079,7 +1033,7 @@ public void test_MapGetAllCodec_decodeRequest() { @Test public void test_MapGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 117; + int fileClientMessageIndex = 111; ClientMessage encoded = MapGetAllCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1087,14 +1041,14 @@ public void test_MapGetAllCodec_encodeResponse() { @Test public void test_MapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 118; + int fileClientMessageIndex = 112; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapValuesCodec.decodeRequest(fromFile))); } @Test public void test_MapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 119; + int fileClientMessageIndex = 113; ClientMessage encoded = MapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1102,14 +1056,14 @@ public void test_MapValuesCodec_encodeResponse() { @Test public void test_MapEntrySetCodec_decodeRequest() { - int fileClientMessageIndex = 120; + int fileClientMessageIndex = 114; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapEntrySetCodec.decodeRequest(fromFile))); } @Test public void test_MapEntrySetCodec_encodeResponse() { - int fileClientMessageIndex = 121; + int fileClientMessageIndex = 115; ClientMessage encoded = MapEntrySetCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1117,7 +1071,7 @@ public void test_MapEntrySetCodec_encodeResponse() { @Test public void test_MapKeySetWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 122; + int fileClientMessageIndex = 116; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapKeySetWithPredicateCodec.RequestParameters parameters = MapKeySetWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1126,7 +1080,7 @@ public void test_MapKeySetWithPredicateCodec_decodeRequest() { @Test public void test_MapKeySetWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 123; + int fileClientMessageIndex = 117; ClientMessage encoded = MapKeySetWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1134,7 +1088,7 @@ public void test_MapKeySetWithPredicateCodec_encodeResponse() { @Test public void test_MapValuesWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 124; + int fileClientMessageIndex = 118; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapValuesWithPredicateCodec.RequestParameters parameters = MapValuesWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1143,7 +1097,7 @@ public void test_MapValuesWithPredicateCodec_decodeRequest() { @Test public void test_MapValuesWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 125; + int fileClientMessageIndex = 119; ClientMessage encoded = MapValuesWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1151,7 +1105,7 @@ public void test_MapValuesWithPredicateCodec_encodeResponse() { @Test public void test_MapEntriesWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 126; + int fileClientMessageIndex = 120; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEntriesWithPredicateCodec.RequestParameters parameters = MapEntriesWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1160,7 +1114,7 @@ public void test_MapEntriesWithPredicateCodec_decodeRequest() { @Test public void test_MapEntriesWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 127; + int fileClientMessageIndex = 121; ClientMessage encoded = MapEntriesWithPredicateCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1168,7 +1122,7 @@ public void test_MapEntriesWithPredicateCodec_encodeResponse() { @Test public void test_MapAddIndexCodec_decodeRequest() { - int fileClientMessageIndex = 128; + int fileClientMessageIndex = 122; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddIndexCodec.RequestParameters parameters = MapAddIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1177,7 +1131,7 @@ public void test_MapAddIndexCodec_decodeRequest() { @Test public void test_MapAddIndexCodec_encodeResponse() { - int fileClientMessageIndex = 129; + int fileClientMessageIndex = 123; ClientMessage encoded = MapAddIndexCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1185,14 +1139,14 @@ public void test_MapAddIndexCodec_encodeResponse() { @Test public void test_MapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 130; + int fileClientMessageIndex = 124; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapSizeCodec.decodeRequest(fromFile))); } @Test public void test_MapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 131; + int fileClientMessageIndex = 125; ClientMessage encoded = MapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1200,14 +1154,14 @@ public void test_MapSizeCodec_encodeResponse() { @Test public void test_MapIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 132; + int fileClientMessageIndex = 126; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_MapIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 133; + int fileClientMessageIndex = 127; ClientMessage encoded = MapIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1215,7 +1169,7 @@ public void test_MapIsEmptyCodec_encodeResponse() { @Test public void test_MapPutAllCodec_decodeRequest() { - int fileClientMessageIndex = 134; + int fileClientMessageIndex = 128; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutAllCodec.RequestParameters parameters = MapPutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1226,7 +1180,7 @@ public void test_MapPutAllCodec_decodeRequest() { @Test public void test_MapPutAllCodec_encodeResponse() { - int fileClientMessageIndex = 135; + int fileClientMessageIndex = 129; ClientMessage encoded = MapPutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1234,14 +1188,14 @@ public void test_MapPutAllCodec_encodeResponse() { @Test public void test_MapClearCodec_decodeRequest() { - int fileClientMessageIndex = 136; + int fileClientMessageIndex = 130; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapClearCodec.decodeRequest(fromFile))); } @Test public void test_MapClearCodec_encodeResponse() { - int fileClientMessageIndex = 137; + int fileClientMessageIndex = 131; ClientMessage encoded = MapClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1249,7 +1203,7 @@ public void test_MapClearCodec_encodeResponse() { @Test public void test_MapExecuteOnKeyCodec_decodeRequest() { - int fileClientMessageIndex = 138; + int fileClientMessageIndex = 132; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteOnKeyCodec.RequestParameters parameters = MapExecuteOnKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1260,7 +1214,7 @@ public void test_MapExecuteOnKeyCodec_decodeRequest() { @Test public void test_MapExecuteOnKeyCodec_encodeResponse() { - int fileClientMessageIndex = 139; + int fileClientMessageIndex = 133; ClientMessage encoded = MapExecuteOnKeyCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1268,7 +1222,7 @@ public void test_MapExecuteOnKeyCodec_encodeResponse() { @Test public void test_MapSubmitToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 140; + int fileClientMessageIndex = 134; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSubmitToKeyCodec.RequestParameters parameters = MapSubmitToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1279,7 +1233,7 @@ public void test_MapSubmitToKeyCodec_decodeRequest() { @Test public void test_MapSubmitToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 141; + int fileClientMessageIndex = 135; ClientMessage encoded = MapSubmitToKeyCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1287,7 +1241,7 @@ public void test_MapSubmitToKeyCodec_encodeResponse() { @Test public void test_MapExecuteOnAllKeysCodec_decodeRequest() { - int fileClientMessageIndex = 142; + int fileClientMessageIndex = 136; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteOnAllKeysCodec.RequestParameters parameters = MapExecuteOnAllKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1296,7 +1250,7 @@ public void test_MapExecuteOnAllKeysCodec_decodeRequest() { @Test public void test_MapExecuteOnAllKeysCodec_encodeResponse() { - int fileClientMessageIndex = 143; + int fileClientMessageIndex = 137; ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1304,7 +1258,7 @@ public void test_MapExecuteOnAllKeysCodec_encodeResponse() { @Test public void test_MapExecuteWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 144; + int fileClientMessageIndex = 138; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteWithPredicateCodec.RequestParameters parameters = MapExecuteWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1314,7 +1268,7 @@ public void test_MapExecuteWithPredicateCodec_decodeRequest() { @Test public void test_MapExecuteWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 145; + int fileClientMessageIndex = 139; ClientMessage encoded = MapExecuteWithPredicateCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1322,7 +1276,7 @@ public void test_MapExecuteWithPredicateCodec_encodeResponse() { @Test public void test_MapExecuteOnKeysCodec_decodeRequest() { - int fileClientMessageIndex = 146; + int fileClientMessageIndex = 140; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapExecuteOnKeysCodec.RequestParameters parameters = MapExecuteOnKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1332,7 +1286,7 @@ public void test_MapExecuteOnKeysCodec_decodeRequest() { @Test public void test_MapExecuteOnKeysCodec_encodeResponse() { - int fileClientMessageIndex = 147; + int fileClientMessageIndex = 141; ClientMessage encoded = MapExecuteOnKeysCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1340,7 +1294,7 @@ public void test_MapExecuteOnKeysCodec_encodeResponse() { @Test public void test_MapForceUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 148; + int fileClientMessageIndex = 142; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapForceUnlockCodec.RequestParameters parameters = MapForceUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1350,7 +1304,7 @@ public void test_MapForceUnlockCodec_decodeRequest() { @Test public void test_MapForceUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 149; + int fileClientMessageIndex = 143; ClientMessage encoded = MapForceUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1358,7 +1312,7 @@ public void test_MapForceUnlockCodec_encodeResponse() { @Test public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 150; + int fileClientMessageIndex = 144; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapKeySetWithPagingPredicateCodec.RequestParameters parameters = MapKeySetWithPagingPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1367,7 +1321,7 @@ public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { @Test public void test_MapKeySetWithPagingPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 151; + int fileClientMessageIndex = 145; ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1375,7 +1329,7 @@ public void test_MapKeySetWithPagingPredicateCodec_encodeResponse() { @Test public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 152; + int fileClientMessageIndex = 146; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapValuesWithPagingPredicateCodec.RequestParameters parameters = MapValuesWithPagingPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1384,7 +1338,7 @@ public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { @Test public void test_MapValuesWithPagingPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 153; + int fileClientMessageIndex = 147; ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1392,7 +1346,7 @@ public void test_MapValuesWithPagingPredicateCodec_encodeResponse() { @Test public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 154; + int fileClientMessageIndex = 148; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEntriesWithPagingPredicateCodec.RequestParameters parameters = MapEntriesWithPagingPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1401,7 +1355,7 @@ public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { @Test public void test_MapEntriesWithPagingPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 155; + int fileClientMessageIndex = 149; ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeResponse(aListOfDataToData, anAnchorDataListHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1409,7 +1363,7 @@ public void test_MapEntriesWithPagingPredicateCodec_encodeResponse() { @Test public void test_MapFetchKeysCodec_decodeRequest() { - int fileClientMessageIndex = 156; + int fileClientMessageIndex = 150; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchKeysCodec.RequestParameters parameters = MapFetchKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1419,7 +1373,7 @@ public void test_MapFetchKeysCodec_decodeRequest() { @Test public void test_MapFetchKeysCodec_encodeResponse() { - int fileClientMessageIndex = 157; + int fileClientMessageIndex = 151; ClientMessage encoded = MapFetchKeysCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1427,7 +1381,7 @@ public void test_MapFetchKeysCodec_encodeResponse() { @Test public void test_MapFetchEntriesCodec_decodeRequest() { - int fileClientMessageIndex = 158; + int fileClientMessageIndex = 152; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchEntriesCodec.RequestParameters parameters = MapFetchEntriesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1437,7 +1391,7 @@ public void test_MapFetchEntriesCodec_decodeRequest() { @Test public void test_MapFetchEntriesCodec_encodeResponse() { - int fileClientMessageIndex = 159; + int fileClientMessageIndex = 153; ClientMessage encoded = MapFetchEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1445,7 +1399,7 @@ public void test_MapFetchEntriesCodec_encodeResponse() { @Test public void test_MapAggregateCodec_decodeRequest() { - int fileClientMessageIndex = 160; + int fileClientMessageIndex = 154; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAggregateCodec.RequestParameters parameters = MapAggregateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1454,7 +1408,7 @@ public void test_MapAggregateCodec_decodeRequest() { @Test public void test_MapAggregateCodec_encodeResponse() { - int fileClientMessageIndex = 161; + int fileClientMessageIndex = 155; ClientMessage encoded = MapAggregateCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1462,7 +1416,7 @@ public void test_MapAggregateCodec_encodeResponse() { @Test public void test_MapAggregateWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 162; + int fileClientMessageIndex = 156; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAggregateWithPredicateCodec.RequestParameters parameters = MapAggregateWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1472,7 +1426,7 @@ public void test_MapAggregateWithPredicateCodec_decodeRequest() { @Test public void test_MapAggregateWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 163; + int fileClientMessageIndex = 157; ClientMessage encoded = MapAggregateWithPredicateCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1480,7 +1434,7 @@ public void test_MapAggregateWithPredicateCodec_encodeResponse() { @Test public void test_MapProjectCodec_decodeRequest() { - int fileClientMessageIndex = 164; + int fileClientMessageIndex = 158; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapProjectCodec.RequestParameters parameters = MapProjectCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1489,7 +1443,7 @@ public void test_MapProjectCodec_decodeRequest() { @Test public void test_MapProjectCodec_encodeResponse() { - int fileClientMessageIndex = 165; + int fileClientMessageIndex = 159; ClientMessage encoded = MapProjectCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1497,7 +1451,7 @@ public void test_MapProjectCodec_encodeResponse() { @Test public void test_MapProjectWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 166; + int fileClientMessageIndex = 160; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapProjectWithPredicateCodec.RequestParameters parameters = MapProjectWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1507,7 +1461,7 @@ public void test_MapProjectWithPredicateCodec_decodeRequest() { @Test public void test_MapProjectWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 167; + int fileClientMessageIndex = 161; ClientMessage encoded = MapProjectWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1515,7 +1469,7 @@ public void test_MapProjectWithPredicateCodec_encodeResponse() { @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { - int fileClientMessageIndex = 168; + int fileClientMessageIndex = 162; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = MapFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); assertTrue(isEqual(aListOfStrings, parameters.names)); @@ -1524,7 +1478,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { @Test public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeResponse() { - int fileClientMessageIndex = 169; + int fileClientMessageIndex = 163; ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1532,7 +1486,7 @@ public void test_MapFetchNearCacheInvalidationMetadataCodec_encodeResponse() { @Test public void test_MapRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 170; + int fileClientMessageIndex = 164; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapRemoveAllCodec.RequestParameters parameters = MapRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1541,7 +1495,7 @@ public void test_MapRemoveAllCodec_decodeRequest() { @Test public void test_MapRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 171; + int fileClientMessageIndex = 165; ClientMessage encoded = MapRemoveAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1549,7 +1503,7 @@ public void test_MapRemoveAllCodec_encodeResponse() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { - int fileClientMessageIndex = 172; + int fileClientMessageIndex = 166; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapAddNearCacheInvalidationListenerCodec.RequestParameters parameters = MapAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1559,7 +1513,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeResponse() { - int fileClientMessageIndex = 173; + int fileClientMessageIndex = 167; ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1567,7 +1521,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeResponse() { @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidationEvent() { - int fileClientMessageIndex = 174; + int fileClientMessageIndex = 168; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapInvalidationEvent(aData, aUUID, aUUID, aLong); compareClientMessages(fromFile, encoded); @@ -1575,7 +1529,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidation @Test public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalidationEvent() { - int fileClientMessageIndex = 175; + int fileClientMessageIndex = 169; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapBatchInvalidationEvent(aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); compareClientMessages(fromFile, encoded); @@ -1583,7 +1537,7 @@ public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalid @Test public void test_MapFetchWithQueryCodec_decodeRequest() { - int fileClientMessageIndex = 176; + int fileClientMessageIndex = 170; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapFetchWithQueryCodec.RequestParameters parameters = MapFetchWithQueryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1595,7 +1549,7 @@ public void test_MapFetchWithQueryCodec_decodeRequest() { @Test public void test_MapFetchWithQueryCodec_encodeResponse() { - int fileClientMessageIndex = 177; + int fileClientMessageIndex = 171; ClientMessage encoded = MapFetchWithQueryCodec.encodeResponse(aListOfData, aListOfIntegerToInteger); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1603,14 +1557,14 @@ public void test_MapFetchWithQueryCodec_encodeResponse() { @Test public void test_MapEventJournalSubscribeCodec_decodeRequest() { - int fileClientMessageIndex = 178; + int fileClientMessageIndex = 172; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MapEventJournalSubscribeCodec.decodeRequest(fromFile))); } @Test public void test_MapEventJournalSubscribeCodec_encodeResponse() { - int fileClientMessageIndex = 179; + int fileClientMessageIndex = 173; ClientMessage encoded = MapEventJournalSubscribeCodec.encodeResponse(aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1618,7 +1572,7 @@ public void test_MapEventJournalSubscribeCodec_encodeResponse() { @Test public void test_MapEventJournalReadCodec_decodeRequest() { - int fileClientMessageIndex = 180; + int fileClientMessageIndex = 174; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapEventJournalReadCodec.RequestParameters parameters = MapEventJournalReadCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1631,7 +1585,7 @@ public void test_MapEventJournalReadCodec_decodeRequest() { @Test public void test_MapEventJournalReadCodec_encodeResponse() { - int fileClientMessageIndex = 181; + int fileClientMessageIndex = 175; ClientMessage encoded = MapEventJournalReadCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1639,7 +1593,7 @@ public void test_MapEventJournalReadCodec_encodeResponse() { @Test public void test_MapSetTtlCodec_decodeRequest() { - int fileClientMessageIndex = 182; + int fileClientMessageIndex = 176; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSetTtlCodec.RequestParameters parameters = MapSetTtlCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1649,7 +1603,7 @@ public void test_MapSetTtlCodec_decodeRequest() { @Test public void test_MapSetTtlCodec_encodeResponse() { - int fileClientMessageIndex = 183; + int fileClientMessageIndex = 177; ClientMessage encoded = MapSetTtlCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1657,7 +1611,7 @@ public void test_MapSetTtlCodec_encodeResponse() { @Test public void test_MapPutWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 184; + int fileClientMessageIndex = 178; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutWithMaxIdleCodec.RequestParameters parameters = MapPutWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1670,7 +1624,7 @@ public void test_MapPutWithMaxIdleCodec_decodeRequest() { @Test public void test_MapPutWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 185; + int fileClientMessageIndex = 179; ClientMessage encoded = MapPutWithMaxIdleCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1678,7 +1632,7 @@ public void test_MapPutWithMaxIdleCodec_encodeResponse() { @Test public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 186; + int fileClientMessageIndex = 180; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutTransientWithMaxIdleCodec.RequestParameters parameters = MapPutTransientWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1691,7 +1645,7 @@ public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { @Test public void test_MapPutTransientWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 187; + int fileClientMessageIndex = 181; ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1699,7 +1653,7 @@ public void test_MapPutTransientWithMaxIdleCodec_encodeResponse() { @Test public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 188; + int fileClientMessageIndex = 182; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapPutIfAbsentWithMaxIdleCodec.RequestParameters parameters = MapPutIfAbsentWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1712,7 +1666,7 @@ public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { @Test public void test_MapPutIfAbsentWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 189; + int fileClientMessageIndex = 183; ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1720,7 +1674,7 @@ public void test_MapPutIfAbsentWithMaxIdleCodec_encodeResponse() { @Test public void test_MapSetWithMaxIdleCodec_decodeRequest() { - int fileClientMessageIndex = 190; + int fileClientMessageIndex = 184; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MapSetWithMaxIdleCodec.RequestParameters parameters = MapSetWithMaxIdleCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1733,7 +1687,7 @@ public void test_MapSetWithMaxIdleCodec_decodeRequest() { @Test public void test_MapSetWithMaxIdleCodec_encodeResponse() { - int fileClientMessageIndex = 191; + int fileClientMessageIndex = 185; ClientMessage encoded = MapSetWithMaxIdleCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1741,7 +1695,7 @@ public void test_MapSetWithMaxIdleCodec_encodeResponse() { @Test public void test_MultiMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 192; + int fileClientMessageIndex = 186; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapPutCodec.RequestParameters parameters = MultiMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1752,7 +1706,7 @@ public void test_MultiMapPutCodec_decodeRequest() { @Test public void test_MultiMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 193; + int fileClientMessageIndex = 187; ClientMessage encoded = MultiMapPutCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1760,7 +1714,7 @@ public void test_MultiMapPutCodec_encodeResponse() { @Test public void test_MultiMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 194; + int fileClientMessageIndex = 188; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapGetCodec.RequestParameters parameters = MultiMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1770,7 +1724,7 @@ public void test_MultiMapGetCodec_decodeRequest() { @Test public void test_MultiMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 195; + int fileClientMessageIndex = 189; ClientMessage encoded = MultiMapGetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1778,7 +1732,7 @@ public void test_MultiMapGetCodec_encodeResponse() { @Test public void test_MultiMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 196; + int fileClientMessageIndex = 190; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapRemoveCodec.RequestParameters parameters = MultiMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1788,7 +1742,7 @@ public void test_MultiMapRemoveCodec_decodeRequest() { @Test public void test_MultiMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 197; + int fileClientMessageIndex = 191; ClientMessage encoded = MultiMapRemoveCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1796,14 +1750,14 @@ public void test_MultiMapRemoveCodec_encodeResponse() { @Test public void test_MultiMapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 198; + int fileClientMessageIndex = 192; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapKeySetCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 199; + int fileClientMessageIndex = 193; ClientMessage encoded = MultiMapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1811,14 +1765,14 @@ public void test_MultiMapKeySetCodec_encodeResponse() { @Test public void test_MultiMapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 200; + int fileClientMessageIndex = 194; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapValuesCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 201; + int fileClientMessageIndex = 195; ClientMessage encoded = MultiMapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1826,14 +1780,14 @@ public void test_MultiMapValuesCodec_encodeResponse() { @Test public void test_MultiMapEntrySetCodec_decodeRequest() { - int fileClientMessageIndex = 202; + int fileClientMessageIndex = 196; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapEntrySetCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapEntrySetCodec_encodeResponse() { - int fileClientMessageIndex = 203; + int fileClientMessageIndex = 197; ClientMessage encoded = MultiMapEntrySetCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1841,7 +1795,7 @@ public void test_MultiMapEntrySetCodec_encodeResponse() { @Test public void test_MultiMapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 204; + int fileClientMessageIndex = 198; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapContainsKeyCodec.RequestParameters parameters = MultiMapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1851,7 +1805,7 @@ public void test_MultiMapContainsKeyCodec_decodeRequest() { @Test public void test_MultiMapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 205; + int fileClientMessageIndex = 199; ClientMessage encoded = MultiMapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1859,7 +1813,7 @@ public void test_MultiMapContainsKeyCodec_encodeResponse() { @Test public void test_MultiMapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 206; + int fileClientMessageIndex = 200; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapContainsValueCodec.RequestParameters parameters = MultiMapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1868,7 +1822,7 @@ public void test_MultiMapContainsValueCodec_decodeRequest() { @Test public void test_MultiMapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 207; + int fileClientMessageIndex = 201; ClientMessage encoded = MultiMapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1876,7 +1830,7 @@ public void test_MultiMapContainsValueCodec_encodeResponse() { @Test public void test_MultiMapContainsEntryCodec_decodeRequest() { - int fileClientMessageIndex = 208; + int fileClientMessageIndex = 202; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapContainsEntryCodec.RequestParameters parameters = MultiMapContainsEntryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1887,7 +1841,7 @@ public void test_MultiMapContainsEntryCodec_decodeRequest() { @Test public void test_MultiMapContainsEntryCodec_encodeResponse() { - int fileClientMessageIndex = 209; + int fileClientMessageIndex = 203; ClientMessage encoded = MultiMapContainsEntryCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1895,14 +1849,14 @@ public void test_MultiMapContainsEntryCodec_encodeResponse() { @Test public void test_MultiMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 210; + int fileClientMessageIndex = 204; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapSizeCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 211; + int fileClientMessageIndex = 205; ClientMessage encoded = MultiMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1910,14 +1864,14 @@ public void test_MultiMapSizeCodec_encodeResponse() { @Test public void test_MultiMapClearCodec_decodeRequest() { - int fileClientMessageIndex = 212; + int fileClientMessageIndex = 206; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MultiMapClearCodec.decodeRequest(fromFile))); } @Test public void test_MultiMapClearCodec_encodeResponse() { - int fileClientMessageIndex = 213; + int fileClientMessageIndex = 207; ClientMessage encoded = MultiMapClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1925,7 +1879,7 @@ public void test_MultiMapClearCodec_encodeResponse() { @Test public void test_MultiMapValueCountCodec_decodeRequest() { - int fileClientMessageIndex = 214; + int fileClientMessageIndex = 208; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapValueCountCodec.RequestParameters parameters = MultiMapValueCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1935,7 +1889,7 @@ public void test_MultiMapValueCountCodec_decodeRequest() { @Test public void test_MultiMapValueCountCodec_encodeResponse() { - int fileClientMessageIndex = 215; + int fileClientMessageIndex = 209; ClientMessage encoded = MultiMapValueCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1943,7 +1897,7 @@ public void test_MultiMapValueCountCodec_encodeResponse() { @Test public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 216; + int fileClientMessageIndex = 210; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapAddEntryListenerToKeyCodec.RequestParameters parameters = MultiMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1954,7 +1908,7 @@ public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { @Test public void test_MultiMapAddEntryListenerToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 217; + int fileClientMessageIndex = 211; ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1962,7 +1916,7 @@ public void test_MultiMapAddEntryListenerToKeyCodec_encodeResponse() { @Test public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { - int fileClientMessageIndex = 218; + int fileClientMessageIndex = 212; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -1970,7 +1924,7 @@ public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { @Test public void test_MultiMapAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 219; + int fileClientMessageIndex = 213; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapAddEntryListenerCodec.RequestParameters parameters = MultiMapAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -1980,7 +1934,7 @@ public void test_MultiMapAddEntryListenerCodec_decodeRequest() { @Test public void test_MultiMapAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 220; + int fileClientMessageIndex = 214; ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -1988,7 +1942,7 @@ public void test_MultiMapAddEntryListenerCodec_encodeResponse() { @Test public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 221; + int fileClientMessageIndex = 215; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -1996,7 +1950,7 @@ public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { @Test public void test_MultiMapRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 222; + int fileClientMessageIndex = 216; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapRemoveEntryListenerCodec.RequestParameters parameters = MultiMapRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2005,7 +1959,7 @@ public void test_MultiMapRemoveEntryListenerCodec_decodeRequest() { @Test public void test_MultiMapRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 223; + int fileClientMessageIndex = 217; ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2013,7 +1967,7 @@ public void test_MultiMapRemoveEntryListenerCodec_encodeResponse() { @Test public void test_MultiMapLockCodec_decodeRequest() { - int fileClientMessageIndex = 224; + int fileClientMessageIndex = 218; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapLockCodec.RequestParameters parameters = MultiMapLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2025,7 +1979,7 @@ public void test_MultiMapLockCodec_decodeRequest() { @Test public void test_MultiMapLockCodec_encodeResponse() { - int fileClientMessageIndex = 225; + int fileClientMessageIndex = 219; ClientMessage encoded = MultiMapLockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2033,7 +1987,7 @@ public void test_MultiMapLockCodec_encodeResponse() { @Test public void test_MultiMapTryLockCodec_decodeRequest() { - int fileClientMessageIndex = 226; + int fileClientMessageIndex = 220; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapTryLockCodec.RequestParameters parameters = MultiMapTryLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2046,7 +2000,7 @@ public void test_MultiMapTryLockCodec_decodeRequest() { @Test public void test_MultiMapTryLockCodec_encodeResponse() { - int fileClientMessageIndex = 227; + int fileClientMessageIndex = 221; ClientMessage encoded = MultiMapTryLockCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2054,7 +2008,7 @@ public void test_MultiMapTryLockCodec_encodeResponse() { @Test public void test_MultiMapIsLockedCodec_decodeRequest() { - int fileClientMessageIndex = 228; + int fileClientMessageIndex = 222; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapIsLockedCodec.RequestParameters parameters = MultiMapIsLockedCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2063,7 +2017,7 @@ public void test_MultiMapIsLockedCodec_decodeRequest() { @Test public void test_MultiMapIsLockedCodec_encodeResponse() { - int fileClientMessageIndex = 229; + int fileClientMessageIndex = 223; ClientMessage encoded = MultiMapIsLockedCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2071,7 +2025,7 @@ public void test_MultiMapIsLockedCodec_encodeResponse() { @Test public void test_MultiMapUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 230; + int fileClientMessageIndex = 224; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapUnlockCodec.RequestParameters parameters = MultiMapUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2082,7 +2036,7 @@ public void test_MultiMapUnlockCodec_decodeRequest() { @Test public void test_MultiMapUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 231; + int fileClientMessageIndex = 225; ClientMessage encoded = MultiMapUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2090,7 +2044,7 @@ public void test_MultiMapUnlockCodec_encodeResponse() { @Test public void test_MultiMapForceUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 232; + int fileClientMessageIndex = 226; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapForceUnlockCodec.RequestParameters parameters = MultiMapForceUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2100,7 +2054,7 @@ public void test_MultiMapForceUnlockCodec_decodeRequest() { @Test public void test_MultiMapForceUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 233; + int fileClientMessageIndex = 227; ClientMessage encoded = MultiMapForceUnlockCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2108,7 +2062,7 @@ public void test_MultiMapForceUnlockCodec_encodeResponse() { @Test public void test_MultiMapRemoveEntryCodec_decodeRequest() { - int fileClientMessageIndex = 234; + int fileClientMessageIndex = 228; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapRemoveEntryCodec.RequestParameters parameters = MultiMapRemoveEntryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2119,7 +2073,7 @@ public void test_MultiMapRemoveEntryCodec_decodeRequest() { @Test public void test_MultiMapRemoveEntryCodec_encodeResponse() { - int fileClientMessageIndex = 235; + int fileClientMessageIndex = 229; ClientMessage encoded = MultiMapRemoveEntryCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2127,7 +2081,7 @@ public void test_MultiMapRemoveEntryCodec_encodeResponse() { @Test public void test_MultiMapDeleteCodec_decodeRequest() { - int fileClientMessageIndex = 236; + int fileClientMessageIndex = 230; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapDeleteCodec.RequestParameters parameters = MultiMapDeleteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2137,7 +2091,7 @@ public void test_MultiMapDeleteCodec_decodeRequest() { @Test public void test_MultiMapDeleteCodec_encodeResponse() { - int fileClientMessageIndex = 237; + int fileClientMessageIndex = 231; ClientMessage encoded = MultiMapDeleteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2145,7 +2099,7 @@ public void test_MultiMapDeleteCodec_encodeResponse() { @Test public void test_MultiMapPutAllCodec_decodeRequest() { - int fileClientMessageIndex = 238; + int fileClientMessageIndex = 232; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MultiMapPutAllCodec.RequestParameters parameters = MultiMapPutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2154,7 +2108,7 @@ public void test_MultiMapPutAllCodec_decodeRequest() { @Test public void test_MultiMapPutAllCodec_encodeResponse() { - int fileClientMessageIndex = 239; + int fileClientMessageIndex = 233; ClientMessage encoded = MultiMapPutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2162,7 +2116,7 @@ public void test_MultiMapPutAllCodec_encodeResponse() { @Test public void test_QueueOfferCodec_decodeRequest() { - int fileClientMessageIndex = 240; + int fileClientMessageIndex = 234; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueOfferCodec.RequestParameters parameters = QueueOfferCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2172,7 +2126,7 @@ public void test_QueueOfferCodec_decodeRequest() { @Test public void test_QueueOfferCodec_encodeResponse() { - int fileClientMessageIndex = 241; + int fileClientMessageIndex = 235; ClientMessage encoded = QueueOfferCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2180,7 +2134,7 @@ public void test_QueueOfferCodec_encodeResponse() { @Test public void test_QueuePutCodec_decodeRequest() { - int fileClientMessageIndex = 242; + int fileClientMessageIndex = 236; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueuePutCodec.RequestParameters parameters = QueuePutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2189,7 +2143,7 @@ public void test_QueuePutCodec_decodeRequest() { @Test public void test_QueuePutCodec_encodeResponse() { - int fileClientMessageIndex = 243; + int fileClientMessageIndex = 237; ClientMessage encoded = QueuePutCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2197,14 +2151,14 @@ public void test_QueuePutCodec_encodeResponse() { @Test public void test_QueueSizeCodec_decodeRequest() { - int fileClientMessageIndex = 244; + int fileClientMessageIndex = 238; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueSizeCodec.decodeRequest(fromFile))); } @Test public void test_QueueSizeCodec_encodeResponse() { - int fileClientMessageIndex = 245; + int fileClientMessageIndex = 239; ClientMessage encoded = QueueSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2212,7 +2166,7 @@ public void test_QueueSizeCodec_encodeResponse() { @Test public void test_QueueRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 246; + int fileClientMessageIndex = 240; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueRemoveCodec.RequestParameters parameters = QueueRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2221,7 +2175,7 @@ public void test_QueueRemoveCodec_decodeRequest() { @Test public void test_QueueRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 247; + int fileClientMessageIndex = 241; ClientMessage encoded = QueueRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2229,7 +2183,7 @@ public void test_QueueRemoveCodec_encodeResponse() { @Test public void test_QueuePollCodec_decodeRequest() { - int fileClientMessageIndex = 248; + int fileClientMessageIndex = 242; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueuePollCodec.RequestParameters parameters = QueuePollCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2238,7 +2192,7 @@ public void test_QueuePollCodec_decodeRequest() { @Test public void test_QueuePollCodec_encodeResponse() { - int fileClientMessageIndex = 249; + int fileClientMessageIndex = 243; ClientMessage encoded = QueuePollCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2246,14 +2200,14 @@ public void test_QueuePollCodec_encodeResponse() { @Test public void test_QueueTakeCodec_decodeRequest() { - int fileClientMessageIndex = 250; + int fileClientMessageIndex = 244; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueTakeCodec.decodeRequest(fromFile))); } @Test public void test_QueueTakeCodec_encodeResponse() { - int fileClientMessageIndex = 251; + int fileClientMessageIndex = 245; ClientMessage encoded = QueueTakeCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2261,14 +2215,14 @@ public void test_QueueTakeCodec_encodeResponse() { @Test public void test_QueuePeekCodec_decodeRequest() { - int fileClientMessageIndex = 252; + int fileClientMessageIndex = 246; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueuePeekCodec.decodeRequest(fromFile))); } @Test public void test_QueuePeekCodec_encodeResponse() { - int fileClientMessageIndex = 253; + int fileClientMessageIndex = 247; ClientMessage encoded = QueuePeekCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2276,14 +2230,14 @@ public void test_QueuePeekCodec_encodeResponse() { @Test public void test_QueueIteratorCodec_decodeRequest() { - int fileClientMessageIndex = 254; + int fileClientMessageIndex = 248; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueIteratorCodec.decodeRequest(fromFile))); } @Test public void test_QueueIteratorCodec_encodeResponse() { - int fileClientMessageIndex = 255; + int fileClientMessageIndex = 249; ClientMessage encoded = QueueIteratorCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2291,14 +2245,14 @@ public void test_QueueIteratorCodec_encodeResponse() { @Test public void test_QueueDrainToCodec_decodeRequest() { - int fileClientMessageIndex = 256; + int fileClientMessageIndex = 250; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueDrainToCodec.decodeRequest(fromFile))); } @Test public void test_QueueDrainToCodec_encodeResponse() { - int fileClientMessageIndex = 257; + int fileClientMessageIndex = 251; ClientMessage encoded = QueueDrainToCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2306,7 +2260,7 @@ public void test_QueueDrainToCodec_encodeResponse() { @Test public void test_QueueDrainToMaxSizeCodec_decodeRequest() { - int fileClientMessageIndex = 258; + int fileClientMessageIndex = 252; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueDrainToMaxSizeCodec.RequestParameters parameters = QueueDrainToMaxSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2315,7 +2269,7 @@ public void test_QueueDrainToMaxSizeCodec_decodeRequest() { @Test public void test_QueueDrainToMaxSizeCodec_encodeResponse() { - int fileClientMessageIndex = 259; + int fileClientMessageIndex = 253; ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2323,7 +2277,7 @@ public void test_QueueDrainToMaxSizeCodec_encodeResponse() { @Test public void test_QueueContainsCodec_decodeRequest() { - int fileClientMessageIndex = 260; + int fileClientMessageIndex = 254; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueContainsCodec.RequestParameters parameters = QueueContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2332,7 +2286,7 @@ public void test_QueueContainsCodec_decodeRequest() { @Test public void test_QueueContainsCodec_encodeResponse() { - int fileClientMessageIndex = 261; + int fileClientMessageIndex = 255; ClientMessage encoded = QueueContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2340,7 +2294,7 @@ public void test_QueueContainsCodec_encodeResponse() { @Test public void test_QueueContainsAllCodec_decodeRequest() { - int fileClientMessageIndex = 262; + int fileClientMessageIndex = 256; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueContainsAllCodec.RequestParameters parameters = QueueContainsAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2349,7 +2303,7 @@ public void test_QueueContainsAllCodec_decodeRequest() { @Test public void test_QueueContainsAllCodec_encodeResponse() { - int fileClientMessageIndex = 263; + int fileClientMessageIndex = 257; ClientMessage encoded = QueueContainsAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2357,7 +2311,7 @@ public void test_QueueContainsAllCodec_encodeResponse() { @Test public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 264; + int fileClientMessageIndex = 258; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueCompareAndRemoveAllCodec.RequestParameters parameters = QueueCompareAndRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2366,7 +2320,7 @@ public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { @Test public void test_QueueCompareAndRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 265; + int fileClientMessageIndex = 259; ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2374,7 +2328,7 @@ public void test_QueueCompareAndRemoveAllCodec_encodeResponse() { @Test public void test_QueueCompareAndRetainAllCodec_decodeRequest() { - int fileClientMessageIndex = 266; + int fileClientMessageIndex = 260; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueCompareAndRetainAllCodec.RequestParameters parameters = QueueCompareAndRetainAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2383,7 +2337,7 @@ public void test_QueueCompareAndRetainAllCodec_decodeRequest() { @Test public void test_QueueCompareAndRetainAllCodec_encodeResponse() { - int fileClientMessageIndex = 267; + int fileClientMessageIndex = 261; ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2391,14 +2345,14 @@ public void test_QueueCompareAndRetainAllCodec_encodeResponse() { @Test public void test_QueueClearCodec_decodeRequest() { - int fileClientMessageIndex = 268; + int fileClientMessageIndex = 262; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueClearCodec.decodeRequest(fromFile))); } @Test public void test_QueueClearCodec_encodeResponse() { - int fileClientMessageIndex = 269; + int fileClientMessageIndex = 263; ClientMessage encoded = QueueClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2406,7 +2360,7 @@ public void test_QueueClearCodec_encodeResponse() { @Test public void test_QueueAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 270; + int fileClientMessageIndex = 264; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueAddAllCodec.RequestParameters parameters = QueueAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2415,7 +2369,7 @@ public void test_QueueAddAllCodec_decodeRequest() { @Test public void test_QueueAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 271; + int fileClientMessageIndex = 265; ClientMessage encoded = QueueAddAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2423,7 +2377,7 @@ public void test_QueueAddAllCodec_encodeResponse() { @Test public void test_QueueAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 272; + int fileClientMessageIndex = 266; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueAddListenerCodec.RequestParameters parameters = QueueAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2433,7 +2387,7 @@ public void test_QueueAddListenerCodec_decodeRequest() { @Test public void test_QueueAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 273; + int fileClientMessageIndex = 267; ClientMessage encoded = QueueAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2441,7 +2395,7 @@ public void test_QueueAddListenerCodec_encodeResponse() { @Test public void test_QueueAddListenerCodec_encodeItemEvent() { - int fileClientMessageIndex = 274; + int fileClientMessageIndex = 268; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = QueueAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -2449,7 +2403,7 @@ public void test_QueueAddListenerCodec_encodeItemEvent() { @Test public void test_QueueRemoveListenerCodec_decodeRequest() { - int fileClientMessageIndex = 275; + int fileClientMessageIndex = 269; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); QueueRemoveListenerCodec.RequestParameters parameters = QueueRemoveListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2458,7 +2412,7 @@ public void test_QueueRemoveListenerCodec_decodeRequest() { @Test public void test_QueueRemoveListenerCodec_encodeResponse() { - int fileClientMessageIndex = 276; + int fileClientMessageIndex = 270; ClientMessage encoded = QueueRemoveListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2466,14 +2420,14 @@ public void test_QueueRemoveListenerCodec_encodeResponse() { @Test public void test_QueueRemainingCapacityCodec_decodeRequest() { - int fileClientMessageIndex = 277; + int fileClientMessageIndex = 271; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueRemainingCapacityCodec.decodeRequest(fromFile))); } @Test public void test_QueueRemainingCapacityCodec_encodeResponse() { - int fileClientMessageIndex = 278; + int fileClientMessageIndex = 272; ClientMessage encoded = QueueRemainingCapacityCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2481,14 +2435,14 @@ public void test_QueueRemainingCapacityCodec_encodeResponse() { @Test public void test_QueueIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 279; + int fileClientMessageIndex = 273; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, QueueIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_QueueIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 280; + int fileClientMessageIndex = 274; ClientMessage encoded = QueueIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2496,7 +2450,7 @@ public void test_QueueIsEmptyCodec_encodeResponse() { @Test public void test_TopicPublishCodec_decodeRequest() { - int fileClientMessageIndex = 281; + int fileClientMessageIndex = 275; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicPublishCodec.RequestParameters parameters = TopicPublishCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2505,7 +2459,7 @@ public void test_TopicPublishCodec_decodeRequest() { @Test public void test_TopicPublishCodec_encodeResponse() { - int fileClientMessageIndex = 282; + int fileClientMessageIndex = 276; ClientMessage encoded = TopicPublishCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2513,7 +2467,7 @@ public void test_TopicPublishCodec_encodeResponse() { @Test public void test_TopicAddMessageListenerCodec_decodeRequest() { - int fileClientMessageIndex = 283; + int fileClientMessageIndex = 277; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicAddMessageListenerCodec.RequestParameters parameters = TopicAddMessageListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2522,7 +2476,7 @@ public void test_TopicAddMessageListenerCodec_decodeRequest() { @Test public void test_TopicAddMessageListenerCodec_encodeResponse() { - int fileClientMessageIndex = 284; + int fileClientMessageIndex = 278; ClientMessage encoded = TopicAddMessageListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2530,7 +2484,7 @@ public void test_TopicAddMessageListenerCodec_encodeResponse() { @Test public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { - int fileClientMessageIndex = 285; + int fileClientMessageIndex = 279; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = TopicAddMessageListenerCodec.encodeTopicEvent(aData, aLong, aUUID); compareClientMessages(fromFile, encoded); @@ -2538,7 +2492,7 @@ public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { @Test public void test_TopicRemoveMessageListenerCodec_decodeRequest() { - int fileClientMessageIndex = 286; + int fileClientMessageIndex = 280; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicRemoveMessageListenerCodec.RequestParameters parameters = TopicRemoveMessageListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2547,7 +2501,7 @@ public void test_TopicRemoveMessageListenerCodec_decodeRequest() { @Test public void test_TopicRemoveMessageListenerCodec_encodeResponse() { - int fileClientMessageIndex = 287; + int fileClientMessageIndex = 281; ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2555,7 +2509,7 @@ public void test_TopicRemoveMessageListenerCodec_encodeResponse() { @Test public void test_TopicPublishAllCodec_decodeRequest() { - int fileClientMessageIndex = 288; + int fileClientMessageIndex = 282; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TopicPublishAllCodec.RequestParameters parameters = TopicPublishAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2564,7 +2518,7 @@ public void test_TopicPublishAllCodec_decodeRequest() { @Test public void test_TopicPublishAllCodec_encodeResponse() { - int fileClientMessageIndex = 289; + int fileClientMessageIndex = 283; ClientMessage encoded = TopicPublishAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2572,14 +2526,14 @@ public void test_TopicPublishAllCodec_encodeResponse() { @Test public void test_ListSizeCodec_decodeRequest() { - int fileClientMessageIndex = 290; + int fileClientMessageIndex = 284; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListSizeCodec.decodeRequest(fromFile))); } @Test public void test_ListSizeCodec_encodeResponse() { - int fileClientMessageIndex = 291; + int fileClientMessageIndex = 285; ClientMessage encoded = ListSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2587,7 +2541,7 @@ public void test_ListSizeCodec_encodeResponse() { @Test public void test_ListContainsCodec_decodeRequest() { - int fileClientMessageIndex = 292; + int fileClientMessageIndex = 286; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListContainsCodec.RequestParameters parameters = ListContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2596,7 +2550,7 @@ public void test_ListContainsCodec_decodeRequest() { @Test public void test_ListContainsCodec_encodeResponse() { - int fileClientMessageIndex = 293; + int fileClientMessageIndex = 287; ClientMessage encoded = ListContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2604,7 +2558,7 @@ public void test_ListContainsCodec_encodeResponse() { @Test public void test_ListContainsAllCodec_decodeRequest() { - int fileClientMessageIndex = 294; + int fileClientMessageIndex = 288; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListContainsAllCodec.RequestParameters parameters = ListContainsAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2613,7 +2567,7 @@ public void test_ListContainsAllCodec_decodeRequest() { @Test public void test_ListContainsAllCodec_encodeResponse() { - int fileClientMessageIndex = 295; + int fileClientMessageIndex = 289; ClientMessage encoded = ListContainsAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2621,7 +2575,7 @@ public void test_ListContainsAllCodec_encodeResponse() { @Test public void test_ListAddCodec_decodeRequest() { - int fileClientMessageIndex = 296; + int fileClientMessageIndex = 290; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddCodec.RequestParameters parameters = ListAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2630,7 +2584,7 @@ public void test_ListAddCodec_decodeRequest() { @Test public void test_ListAddCodec_encodeResponse() { - int fileClientMessageIndex = 297; + int fileClientMessageIndex = 291; ClientMessage encoded = ListAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2638,7 +2592,7 @@ public void test_ListAddCodec_encodeResponse() { @Test public void test_ListRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 298; + int fileClientMessageIndex = 292; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListRemoveCodec.RequestParameters parameters = ListRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2647,7 +2601,7 @@ public void test_ListRemoveCodec_decodeRequest() { @Test public void test_ListRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 299; + int fileClientMessageIndex = 293; ClientMessage encoded = ListRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2655,7 +2609,7 @@ public void test_ListRemoveCodec_encodeResponse() { @Test public void test_ListAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 300; + int fileClientMessageIndex = 294; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddAllCodec.RequestParameters parameters = ListAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2664,7 +2618,7 @@ public void test_ListAddAllCodec_decodeRequest() { @Test public void test_ListAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 301; + int fileClientMessageIndex = 295; ClientMessage encoded = ListAddAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2672,7 +2626,7 @@ public void test_ListAddAllCodec_encodeResponse() { @Test public void test_ListCompareAndRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 302; + int fileClientMessageIndex = 296; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListCompareAndRemoveAllCodec.RequestParameters parameters = ListCompareAndRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2681,7 +2635,7 @@ public void test_ListCompareAndRemoveAllCodec_decodeRequest() { @Test public void test_ListCompareAndRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 303; + int fileClientMessageIndex = 297; ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2689,7 +2643,7 @@ public void test_ListCompareAndRemoveAllCodec_encodeResponse() { @Test public void test_ListCompareAndRetainAllCodec_decodeRequest() { - int fileClientMessageIndex = 304; + int fileClientMessageIndex = 298; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListCompareAndRetainAllCodec.RequestParameters parameters = ListCompareAndRetainAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2698,7 +2652,7 @@ public void test_ListCompareAndRetainAllCodec_decodeRequest() { @Test public void test_ListCompareAndRetainAllCodec_encodeResponse() { - int fileClientMessageIndex = 305; + int fileClientMessageIndex = 299; ClientMessage encoded = ListCompareAndRetainAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2706,14 +2660,14 @@ public void test_ListCompareAndRetainAllCodec_encodeResponse() { @Test public void test_ListClearCodec_decodeRequest() { - int fileClientMessageIndex = 306; + int fileClientMessageIndex = 300; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListClearCodec.decodeRequest(fromFile))); } @Test public void test_ListClearCodec_encodeResponse() { - int fileClientMessageIndex = 307; + int fileClientMessageIndex = 301; ClientMessage encoded = ListClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2721,14 +2675,14 @@ public void test_ListClearCodec_encodeResponse() { @Test public void test_ListGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 308; + int fileClientMessageIndex = 302; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListGetAllCodec.decodeRequest(fromFile))); } @Test public void test_ListGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 309; + int fileClientMessageIndex = 303; ClientMessage encoded = ListGetAllCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2736,7 +2690,7 @@ public void test_ListGetAllCodec_encodeResponse() { @Test public void test_ListAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 310; + int fileClientMessageIndex = 304; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddListenerCodec.RequestParameters parameters = ListAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2746,7 +2700,7 @@ public void test_ListAddListenerCodec_decodeRequest() { @Test public void test_ListAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 311; + int fileClientMessageIndex = 305; ClientMessage encoded = ListAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2754,7 +2708,7 @@ public void test_ListAddListenerCodec_encodeResponse() { @Test public void test_ListAddListenerCodec_encodeItemEvent() { - int fileClientMessageIndex = 312; + int fileClientMessageIndex = 306; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ListAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -2762,7 +2716,7 @@ public void test_ListAddListenerCodec_encodeItemEvent() { @Test public void test_ListRemoveListenerCodec_decodeRequest() { - int fileClientMessageIndex = 313; + int fileClientMessageIndex = 307; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListRemoveListenerCodec.RequestParameters parameters = ListRemoveListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2771,7 +2725,7 @@ public void test_ListRemoveListenerCodec_decodeRequest() { @Test public void test_ListRemoveListenerCodec_encodeResponse() { - int fileClientMessageIndex = 314; + int fileClientMessageIndex = 308; ClientMessage encoded = ListRemoveListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2779,14 +2733,14 @@ public void test_ListRemoveListenerCodec_encodeResponse() { @Test public void test_ListIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 315; + int fileClientMessageIndex = 309; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_ListIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 316; + int fileClientMessageIndex = 310; ClientMessage encoded = ListIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2794,7 +2748,7 @@ public void test_ListIsEmptyCodec_encodeResponse() { @Test public void test_ListAddAllWithIndexCodec_decodeRequest() { - int fileClientMessageIndex = 317; + int fileClientMessageIndex = 311; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddAllWithIndexCodec.RequestParameters parameters = ListAddAllWithIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2804,7 +2758,7 @@ public void test_ListAddAllWithIndexCodec_decodeRequest() { @Test public void test_ListAddAllWithIndexCodec_encodeResponse() { - int fileClientMessageIndex = 318; + int fileClientMessageIndex = 312; ClientMessage encoded = ListAddAllWithIndexCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2812,7 +2766,7 @@ public void test_ListAddAllWithIndexCodec_encodeResponse() { @Test public void test_ListGetCodec_decodeRequest() { - int fileClientMessageIndex = 319; + int fileClientMessageIndex = 313; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListGetCodec.RequestParameters parameters = ListGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2821,7 +2775,7 @@ public void test_ListGetCodec_decodeRequest() { @Test public void test_ListGetCodec_encodeResponse() { - int fileClientMessageIndex = 320; + int fileClientMessageIndex = 314; ClientMessage encoded = ListGetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2829,7 +2783,7 @@ public void test_ListGetCodec_encodeResponse() { @Test public void test_ListSetCodec_decodeRequest() { - int fileClientMessageIndex = 321; + int fileClientMessageIndex = 315; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListSetCodec.RequestParameters parameters = ListSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2839,7 +2793,7 @@ public void test_ListSetCodec_decodeRequest() { @Test public void test_ListSetCodec_encodeResponse() { - int fileClientMessageIndex = 322; + int fileClientMessageIndex = 316; ClientMessage encoded = ListSetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2847,7 +2801,7 @@ public void test_ListSetCodec_encodeResponse() { @Test public void test_ListAddWithIndexCodec_decodeRequest() { - int fileClientMessageIndex = 323; + int fileClientMessageIndex = 317; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListAddWithIndexCodec.RequestParameters parameters = ListAddWithIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2857,7 +2811,7 @@ public void test_ListAddWithIndexCodec_decodeRequest() { @Test public void test_ListAddWithIndexCodec_encodeResponse() { - int fileClientMessageIndex = 324; + int fileClientMessageIndex = 318; ClientMessage encoded = ListAddWithIndexCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2865,7 +2819,7 @@ public void test_ListAddWithIndexCodec_encodeResponse() { @Test public void test_ListRemoveWithIndexCodec_decodeRequest() { - int fileClientMessageIndex = 325; + int fileClientMessageIndex = 319; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListRemoveWithIndexCodec.RequestParameters parameters = ListRemoveWithIndexCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2874,7 +2828,7 @@ public void test_ListRemoveWithIndexCodec_decodeRequest() { @Test public void test_ListRemoveWithIndexCodec_encodeResponse() { - int fileClientMessageIndex = 326; + int fileClientMessageIndex = 320; ClientMessage encoded = ListRemoveWithIndexCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2882,7 +2836,7 @@ public void test_ListRemoveWithIndexCodec_encodeResponse() { @Test public void test_ListLastIndexOfCodec_decodeRequest() { - int fileClientMessageIndex = 327; + int fileClientMessageIndex = 321; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListLastIndexOfCodec.RequestParameters parameters = ListLastIndexOfCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2891,7 +2845,7 @@ public void test_ListLastIndexOfCodec_decodeRequest() { @Test public void test_ListLastIndexOfCodec_encodeResponse() { - int fileClientMessageIndex = 328; + int fileClientMessageIndex = 322; ClientMessage encoded = ListLastIndexOfCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2899,7 +2853,7 @@ public void test_ListLastIndexOfCodec_encodeResponse() { @Test public void test_ListIndexOfCodec_decodeRequest() { - int fileClientMessageIndex = 329; + int fileClientMessageIndex = 323; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListIndexOfCodec.RequestParameters parameters = ListIndexOfCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2908,7 +2862,7 @@ public void test_ListIndexOfCodec_decodeRequest() { @Test public void test_ListIndexOfCodec_encodeResponse() { - int fileClientMessageIndex = 330; + int fileClientMessageIndex = 324; ClientMessage encoded = ListIndexOfCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2916,7 +2870,7 @@ public void test_ListIndexOfCodec_encodeResponse() { @Test public void test_ListSubCodec_decodeRequest() { - int fileClientMessageIndex = 331; + int fileClientMessageIndex = 325; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListSubCodec.RequestParameters parameters = ListSubCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2926,7 +2880,7 @@ public void test_ListSubCodec_decodeRequest() { @Test public void test_ListSubCodec_encodeResponse() { - int fileClientMessageIndex = 332; + int fileClientMessageIndex = 326; ClientMessage encoded = ListSubCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2934,14 +2888,14 @@ public void test_ListSubCodec_encodeResponse() { @Test public void test_ListIteratorCodec_decodeRequest() { - int fileClientMessageIndex = 333; + int fileClientMessageIndex = 327; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ListIteratorCodec.decodeRequest(fromFile))); } @Test public void test_ListIteratorCodec_encodeResponse() { - int fileClientMessageIndex = 334; + int fileClientMessageIndex = 328; ClientMessage encoded = ListIteratorCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2949,7 +2903,7 @@ public void test_ListIteratorCodec_encodeResponse() { @Test public void test_ListListIteratorCodec_decodeRequest() { - int fileClientMessageIndex = 335; + int fileClientMessageIndex = 329; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ListListIteratorCodec.RequestParameters parameters = ListListIteratorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2958,7 +2912,7 @@ public void test_ListListIteratorCodec_decodeRequest() { @Test public void test_ListListIteratorCodec_encodeResponse() { - int fileClientMessageIndex = 336; + int fileClientMessageIndex = 330; ClientMessage encoded = ListListIteratorCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2966,14 +2920,14 @@ public void test_ListListIteratorCodec_encodeResponse() { @Test public void test_SetSizeCodec_decodeRequest() { - int fileClientMessageIndex = 337; + int fileClientMessageIndex = 331; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetSizeCodec.decodeRequest(fromFile))); } @Test public void test_SetSizeCodec_encodeResponse() { - int fileClientMessageIndex = 338; + int fileClientMessageIndex = 332; ClientMessage encoded = SetSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2981,7 +2935,7 @@ public void test_SetSizeCodec_encodeResponse() { @Test public void test_SetContainsCodec_decodeRequest() { - int fileClientMessageIndex = 339; + int fileClientMessageIndex = 333; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetContainsCodec.RequestParameters parameters = SetContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -2990,7 +2944,7 @@ public void test_SetContainsCodec_decodeRequest() { @Test public void test_SetContainsCodec_encodeResponse() { - int fileClientMessageIndex = 340; + int fileClientMessageIndex = 334; ClientMessage encoded = SetContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -2998,7 +2952,7 @@ public void test_SetContainsCodec_encodeResponse() { @Test public void test_SetContainsAllCodec_decodeRequest() { - int fileClientMessageIndex = 341; + int fileClientMessageIndex = 335; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetContainsAllCodec.RequestParameters parameters = SetContainsAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3007,7 +2961,7 @@ public void test_SetContainsAllCodec_decodeRequest() { @Test public void test_SetContainsAllCodec_encodeResponse() { - int fileClientMessageIndex = 342; + int fileClientMessageIndex = 336; ClientMessage encoded = SetContainsAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3015,7 +2969,7 @@ public void test_SetContainsAllCodec_encodeResponse() { @Test public void test_SetAddCodec_decodeRequest() { - int fileClientMessageIndex = 343; + int fileClientMessageIndex = 337; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetAddCodec.RequestParameters parameters = SetAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3024,7 +2978,7 @@ public void test_SetAddCodec_decodeRequest() { @Test public void test_SetAddCodec_encodeResponse() { - int fileClientMessageIndex = 344; + int fileClientMessageIndex = 338; ClientMessage encoded = SetAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3032,7 +2986,7 @@ public void test_SetAddCodec_encodeResponse() { @Test public void test_SetRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 345; + int fileClientMessageIndex = 339; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetRemoveCodec.RequestParameters parameters = SetRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3041,7 +2995,7 @@ public void test_SetRemoveCodec_decodeRequest() { @Test public void test_SetRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 346; + int fileClientMessageIndex = 340; ClientMessage encoded = SetRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3049,7 +3003,7 @@ public void test_SetRemoveCodec_encodeResponse() { @Test public void test_SetAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 347; + int fileClientMessageIndex = 341; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetAddAllCodec.RequestParameters parameters = SetAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3058,7 +3012,7 @@ public void test_SetAddAllCodec_decodeRequest() { @Test public void test_SetAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 348; + int fileClientMessageIndex = 342; ClientMessage encoded = SetAddAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3066,7 +3020,7 @@ public void test_SetAddAllCodec_encodeResponse() { @Test public void test_SetCompareAndRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 349; + int fileClientMessageIndex = 343; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetCompareAndRemoveAllCodec.RequestParameters parameters = SetCompareAndRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3075,7 +3029,7 @@ public void test_SetCompareAndRemoveAllCodec_decodeRequest() { @Test public void test_SetCompareAndRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 350; + int fileClientMessageIndex = 344; ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3083,7 +3037,7 @@ public void test_SetCompareAndRemoveAllCodec_encodeResponse() { @Test public void test_SetCompareAndRetainAllCodec_decodeRequest() { - int fileClientMessageIndex = 351; + int fileClientMessageIndex = 345; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetCompareAndRetainAllCodec.RequestParameters parameters = SetCompareAndRetainAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3092,7 +3046,7 @@ public void test_SetCompareAndRetainAllCodec_decodeRequest() { @Test public void test_SetCompareAndRetainAllCodec_encodeResponse() { - int fileClientMessageIndex = 352; + int fileClientMessageIndex = 346; ClientMessage encoded = SetCompareAndRetainAllCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3100,14 +3054,14 @@ public void test_SetCompareAndRetainAllCodec_encodeResponse() { @Test public void test_SetClearCodec_decodeRequest() { - int fileClientMessageIndex = 353; + int fileClientMessageIndex = 347; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetClearCodec.decodeRequest(fromFile))); } @Test public void test_SetClearCodec_encodeResponse() { - int fileClientMessageIndex = 354; + int fileClientMessageIndex = 348; ClientMessage encoded = SetClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3115,14 +3069,14 @@ public void test_SetClearCodec_encodeResponse() { @Test public void test_SetGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 355; + int fileClientMessageIndex = 349; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetGetAllCodec.decodeRequest(fromFile))); } @Test public void test_SetGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 356; + int fileClientMessageIndex = 350; ClientMessage encoded = SetGetAllCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3130,7 +3084,7 @@ public void test_SetGetAllCodec_encodeResponse() { @Test public void test_SetAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 357; + int fileClientMessageIndex = 351; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetAddListenerCodec.RequestParameters parameters = SetAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3140,7 +3094,7 @@ public void test_SetAddListenerCodec_decodeRequest() { @Test public void test_SetAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 358; + int fileClientMessageIndex = 352; ClientMessage encoded = SetAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3148,7 +3102,7 @@ public void test_SetAddListenerCodec_encodeResponse() { @Test public void test_SetAddListenerCodec_encodeItemEvent() { - int fileClientMessageIndex = 359; + int fileClientMessageIndex = 353; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = SetAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -3156,7 +3110,7 @@ public void test_SetAddListenerCodec_encodeItemEvent() { @Test public void test_SetRemoveListenerCodec_decodeRequest() { - int fileClientMessageIndex = 360; + int fileClientMessageIndex = 354; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SetRemoveListenerCodec.RequestParameters parameters = SetRemoveListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3165,7 +3119,7 @@ public void test_SetRemoveListenerCodec_decodeRequest() { @Test public void test_SetRemoveListenerCodec_encodeResponse() { - int fileClientMessageIndex = 361; + int fileClientMessageIndex = 355; ClientMessage encoded = SetRemoveListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3173,14 +3127,14 @@ public void test_SetRemoveListenerCodec_encodeResponse() { @Test public void test_SetIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 362; + int fileClientMessageIndex = 356; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SetIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_SetIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 363; + int fileClientMessageIndex = 357; ClientMessage encoded = SetIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3188,7 +3142,7 @@ public void test_SetIsEmptyCodec_encodeResponse() { @Test public void test_FencedLockLockCodec_decodeRequest() { - int fileClientMessageIndex = 364; + int fileClientMessageIndex = 358; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockLockCodec.RequestParameters parameters = FencedLockLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3200,7 +3154,7 @@ public void test_FencedLockLockCodec_decodeRequest() { @Test public void test_FencedLockLockCodec_encodeResponse() { - int fileClientMessageIndex = 365; + int fileClientMessageIndex = 359; ClientMessage encoded = FencedLockLockCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3208,7 +3162,7 @@ public void test_FencedLockLockCodec_encodeResponse() { @Test public void test_FencedLockTryLockCodec_decodeRequest() { - int fileClientMessageIndex = 366; + int fileClientMessageIndex = 360; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockTryLockCodec.RequestParameters parameters = FencedLockTryLockCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3221,7 +3175,7 @@ public void test_FencedLockTryLockCodec_decodeRequest() { @Test public void test_FencedLockTryLockCodec_encodeResponse() { - int fileClientMessageIndex = 367; + int fileClientMessageIndex = 361; ClientMessage encoded = FencedLockTryLockCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3229,7 +3183,7 @@ public void test_FencedLockTryLockCodec_encodeResponse() { @Test public void test_FencedLockUnlockCodec_decodeRequest() { - int fileClientMessageIndex = 368; + int fileClientMessageIndex = 362; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockUnlockCodec.RequestParameters parameters = FencedLockUnlockCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3241,7 +3195,7 @@ public void test_FencedLockUnlockCodec_decodeRequest() { @Test public void test_FencedLockUnlockCodec_encodeResponse() { - int fileClientMessageIndex = 369; + int fileClientMessageIndex = 363; ClientMessage encoded = FencedLockUnlockCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3249,7 +3203,7 @@ public void test_FencedLockUnlockCodec_encodeResponse() { @Test public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { - int fileClientMessageIndex = 370; + int fileClientMessageIndex = 364; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FencedLockGetLockOwnershipCodec.RequestParameters parameters = FencedLockGetLockOwnershipCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3258,7 +3212,7 @@ public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { @Test public void test_FencedLockGetLockOwnershipCodec_encodeResponse() { - int fileClientMessageIndex = 371; + int fileClientMessageIndex = 365; ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeResponse(aLong, anInt, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3266,14 +3220,14 @@ public void test_FencedLockGetLockOwnershipCodec_encodeResponse() { @Test public void test_ExecutorServiceShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 372; + int fileClientMessageIndex = 366; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ExecutorServiceShutdownCodec.decodeRequest(fromFile))); } @Test public void test_ExecutorServiceShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 373; + int fileClientMessageIndex = 367; ClientMessage encoded = ExecutorServiceShutdownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3281,14 +3235,14 @@ public void test_ExecutorServiceShutdownCodec_encodeResponse() { @Test public void test_ExecutorServiceIsShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 374; + int fileClientMessageIndex = 368; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ExecutorServiceIsShutdownCodec.decodeRequest(fromFile))); } @Test public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 375; + int fileClientMessageIndex = 369; ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3296,7 +3250,7 @@ public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { @Test public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 376; + int fileClientMessageIndex = 370; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceCancelOnPartitionCodec.RequestParameters parameters = ExecutorServiceCancelOnPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.uuid)); @@ -3305,7 +3259,7 @@ public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { @Test public void test_ExecutorServiceCancelOnPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 377; + int fileClientMessageIndex = 371; ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3313,7 +3267,7 @@ public void test_ExecutorServiceCancelOnPartitionCodec_encodeResponse() { @Test public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { - int fileClientMessageIndex = 378; + int fileClientMessageIndex = 372; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceCancelOnMemberCodec.RequestParameters parameters = ExecutorServiceCancelOnMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.uuid)); @@ -3323,7 +3277,7 @@ public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { @Test public void test_ExecutorServiceCancelOnMemberCodec_encodeResponse() { - int fileClientMessageIndex = 379; + int fileClientMessageIndex = 373; ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3331,7 +3285,7 @@ public void test_ExecutorServiceCancelOnMemberCodec_encodeResponse() { @Test public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 380; + int fileClientMessageIndex = 374; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceSubmitToPartitionCodec.RequestParameters parameters = ExecutorServiceSubmitToPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3341,7 +3295,7 @@ public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { @Test public void test_ExecutorServiceSubmitToPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 381; + int fileClientMessageIndex = 375; ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3349,7 +3303,7 @@ public void test_ExecutorServiceSubmitToPartitionCodec_encodeResponse() { @Test public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { - int fileClientMessageIndex = 382; + int fileClientMessageIndex = 376; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ExecutorServiceSubmitToMemberCodec.RequestParameters parameters = ExecutorServiceSubmitToMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3360,7 +3314,7 @@ public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { @Test public void test_ExecutorServiceSubmitToMemberCodec_encodeResponse() { - int fileClientMessageIndex = 383; + int fileClientMessageIndex = 377; ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3368,7 +3322,7 @@ public void test_ExecutorServiceSubmitToMemberCodec_encodeResponse() { @Test public void test_AtomicLongApplyCodec_decodeRequest() { - int fileClientMessageIndex = 384; + int fileClientMessageIndex = 378; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongApplyCodec.RequestParameters parameters = AtomicLongApplyCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3378,7 +3332,7 @@ public void test_AtomicLongApplyCodec_decodeRequest() { @Test public void test_AtomicLongApplyCodec_encodeResponse() { - int fileClientMessageIndex = 385; + int fileClientMessageIndex = 379; ClientMessage encoded = AtomicLongApplyCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3386,7 +3340,7 @@ public void test_AtomicLongApplyCodec_encodeResponse() { @Test public void test_AtomicLongAlterCodec_decodeRequest() { - int fileClientMessageIndex = 386; + int fileClientMessageIndex = 380; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongAlterCodec.RequestParameters parameters = AtomicLongAlterCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3397,7 +3351,7 @@ public void test_AtomicLongAlterCodec_decodeRequest() { @Test public void test_AtomicLongAlterCodec_encodeResponse() { - int fileClientMessageIndex = 387; + int fileClientMessageIndex = 381; ClientMessage encoded = AtomicLongAlterCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3405,7 +3359,7 @@ public void test_AtomicLongAlterCodec_encodeResponse() { @Test public void test_AtomicLongAddAndGetCodec_decodeRequest() { - int fileClientMessageIndex = 388; + int fileClientMessageIndex = 382; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongAddAndGetCodec.RequestParameters parameters = AtomicLongAddAndGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3415,7 +3369,7 @@ public void test_AtomicLongAddAndGetCodec_decodeRequest() { @Test public void test_AtomicLongAddAndGetCodec_encodeResponse() { - int fileClientMessageIndex = 389; + int fileClientMessageIndex = 383; ClientMessage encoded = AtomicLongAddAndGetCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3423,7 +3377,7 @@ public void test_AtomicLongAddAndGetCodec_encodeResponse() { @Test public void test_AtomicLongCompareAndSetCodec_decodeRequest() { - int fileClientMessageIndex = 390; + int fileClientMessageIndex = 384; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongCompareAndSetCodec.RequestParameters parameters = AtomicLongCompareAndSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3434,7 +3388,7 @@ public void test_AtomicLongCompareAndSetCodec_decodeRequest() { @Test public void test_AtomicLongCompareAndSetCodec_encodeResponse() { - int fileClientMessageIndex = 391; + int fileClientMessageIndex = 385; ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3442,7 +3396,7 @@ public void test_AtomicLongCompareAndSetCodec_encodeResponse() { @Test public void test_AtomicLongGetCodec_decodeRequest() { - int fileClientMessageIndex = 392; + int fileClientMessageIndex = 386; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongGetCodec.RequestParameters parameters = AtomicLongGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3451,7 +3405,7 @@ public void test_AtomicLongGetCodec_decodeRequest() { @Test public void test_AtomicLongGetCodec_encodeResponse() { - int fileClientMessageIndex = 393; + int fileClientMessageIndex = 387; ClientMessage encoded = AtomicLongGetCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3459,7 +3413,7 @@ public void test_AtomicLongGetCodec_encodeResponse() { @Test public void test_AtomicLongGetAndAddCodec_decodeRequest() { - int fileClientMessageIndex = 394; + int fileClientMessageIndex = 388; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongGetAndAddCodec.RequestParameters parameters = AtomicLongGetAndAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3469,7 +3423,7 @@ public void test_AtomicLongGetAndAddCodec_decodeRequest() { @Test public void test_AtomicLongGetAndAddCodec_encodeResponse() { - int fileClientMessageIndex = 395; + int fileClientMessageIndex = 389; ClientMessage encoded = AtomicLongGetAndAddCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3477,7 +3431,7 @@ public void test_AtomicLongGetAndAddCodec_encodeResponse() { @Test public void test_AtomicLongGetAndSetCodec_decodeRequest() { - int fileClientMessageIndex = 396; + int fileClientMessageIndex = 390; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicLongGetAndSetCodec.RequestParameters parameters = AtomicLongGetAndSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3487,7 +3441,7 @@ public void test_AtomicLongGetAndSetCodec_decodeRequest() { @Test public void test_AtomicLongGetAndSetCodec_encodeResponse() { - int fileClientMessageIndex = 397; + int fileClientMessageIndex = 391; ClientMessage encoded = AtomicLongGetAndSetCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3495,7 +3449,7 @@ public void test_AtomicLongGetAndSetCodec_encodeResponse() { @Test public void test_AtomicRefApplyCodec_decodeRequest() { - int fileClientMessageIndex = 398; + int fileClientMessageIndex = 392; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefApplyCodec.RequestParameters parameters = AtomicRefApplyCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3507,7 +3461,7 @@ public void test_AtomicRefApplyCodec_decodeRequest() { @Test public void test_AtomicRefApplyCodec_encodeResponse() { - int fileClientMessageIndex = 399; + int fileClientMessageIndex = 393; ClientMessage encoded = AtomicRefApplyCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3515,7 +3469,7 @@ public void test_AtomicRefApplyCodec_encodeResponse() { @Test public void test_AtomicRefCompareAndSetCodec_decodeRequest() { - int fileClientMessageIndex = 400; + int fileClientMessageIndex = 394; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefCompareAndSetCodec.RequestParameters parameters = AtomicRefCompareAndSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3526,7 +3480,7 @@ public void test_AtomicRefCompareAndSetCodec_decodeRequest() { @Test public void test_AtomicRefCompareAndSetCodec_encodeResponse() { - int fileClientMessageIndex = 401; + int fileClientMessageIndex = 395; ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3534,7 +3488,7 @@ public void test_AtomicRefCompareAndSetCodec_encodeResponse() { @Test public void test_AtomicRefContainsCodec_decodeRequest() { - int fileClientMessageIndex = 402; + int fileClientMessageIndex = 396; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefContainsCodec.RequestParameters parameters = AtomicRefContainsCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3544,7 +3498,7 @@ public void test_AtomicRefContainsCodec_decodeRequest() { @Test public void test_AtomicRefContainsCodec_encodeResponse() { - int fileClientMessageIndex = 403; + int fileClientMessageIndex = 397; ClientMessage encoded = AtomicRefContainsCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3552,7 +3506,7 @@ public void test_AtomicRefContainsCodec_encodeResponse() { @Test public void test_AtomicRefGetCodec_decodeRequest() { - int fileClientMessageIndex = 404; + int fileClientMessageIndex = 398; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefGetCodec.RequestParameters parameters = AtomicRefGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3561,7 +3515,7 @@ public void test_AtomicRefGetCodec_decodeRequest() { @Test public void test_AtomicRefGetCodec_encodeResponse() { - int fileClientMessageIndex = 405; + int fileClientMessageIndex = 399; ClientMessage encoded = AtomicRefGetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3569,7 +3523,7 @@ public void test_AtomicRefGetCodec_encodeResponse() { @Test public void test_AtomicRefSetCodec_decodeRequest() { - int fileClientMessageIndex = 406; + int fileClientMessageIndex = 400; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); AtomicRefSetCodec.RequestParameters parameters = AtomicRefSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3580,7 +3534,7 @@ public void test_AtomicRefSetCodec_decodeRequest() { @Test public void test_AtomicRefSetCodec_encodeResponse() { - int fileClientMessageIndex = 407; + int fileClientMessageIndex = 401; ClientMessage encoded = AtomicRefSetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3588,7 +3542,7 @@ public void test_AtomicRefSetCodec_encodeResponse() { @Test public void test_CountDownLatchTrySetCountCodec_decodeRequest() { - int fileClientMessageIndex = 408; + int fileClientMessageIndex = 402; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchTrySetCountCodec.RequestParameters parameters = CountDownLatchTrySetCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3598,7 +3552,7 @@ public void test_CountDownLatchTrySetCountCodec_decodeRequest() { @Test public void test_CountDownLatchTrySetCountCodec_encodeResponse() { - int fileClientMessageIndex = 409; + int fileClientMessageIndex = 403; ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3606,7 +3560,7 @@ public void test_CountDownLatchTrySetCountCodec_encodeResponse() { @Test public void test_CountDownLatchAwaitCodec_decodeRequest() { - int fileClientMessageIndex = 410; + int fileClientMessageIndex = 404; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchAwaitCodec.RequestParameters parameters = CountDownLatchAwaitCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3617,7 +3571,7 @@ public void test_CountDownLatchAwaitCodec_decodeRequest() { @Test public void test_CountDownLatchAwaitCodec_encodeResponse() { - int fileClientMessageIndex = 411; + int fileClientMessageIndex = 405; ClientMessage encoded = CountDownLatchAwaitCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3625,7 +3579,7 @@ public void test_CountDownLatchAwaitCodec_encodeResponse() { @Test public void test_CountDownLatchCountDownCodec_decodeRequest() { - int fileClientMessageIndex = 412; + int fileClientMessageIndex = 406; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchCountDownCodec.RequestParameters parameters = CountDownLatchCountDownCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3636,7 +3590,7 @@ public void test_CountDownLatchCountDownCodec_decodeRequest() { @Test public void test_CountDownLatchCountDownCodec_encodeResponse() { - int fileClientMessageIndex = 413; + int fileClientMessageIndex = 407; ClientMessage encoded = CountDownLatchCountDownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3644,7 +3598,7 @@ public void test_CountDownLatchCountDownCodec_encodeResponse() { @Test public void test_CountDownLatchGetCountCodec_decodeRequest() { - int fileClientMessageIndex = 414; + int fileClientMessageIndex = 408; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchGetCountCodec.RequestParameters parameters = CountDownLatchGetCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3653,7 +3607,7 @@ public void test_CountDownLatchGetCountCodec_decodeRequest() { @Test public void test_CountDownLatchGetCountCodec_encodeResponse() { - int fileClientMessageIndex = 415; + int fileClientMessageIndex = 409; ClientMessage encoded = CountDownLatchGetCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3661,7 +3615,7 @@ public void test_CountDownLatchGetCountCodec_encodeResponse() { @Test public void test_CountDownLatchGetRoundCodec_decodeRequest() { - int fileClientMessageIndex = 416; + int fileClientMessageIndex = 410; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CountDownLatchGetRoundCodec.RequestParameters parameters = CountDownLatchGetRoundCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3670,7 +3624,7 @@ public void test_CountDownLatchGetRoundCodec_decodeRequest() { @Test public void test_CountDownLatchGetRoundCodec_encodeResponse() { - int fileClientMessageIndex = 417; + int fileClientMessageIndex = 411; ClientMessage encoded = CountDownLatchGetRoundCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3678,7 +3632,7 @@ public void test_CountDownLatchGetRoundCodec_encodeResponse() { @Test public void test_SemaphoreInitCodec_decodeRequest() { - int fileClientMessageIndex = 418; + int fileClientMessageIndex = 412; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreInitCodec.RequestParameters parameters = SemaphoreInitCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3688,7 +3642,7 @@ public void test_SemaphoreInitCodec_decodeRequest() { @Test public void test_SemaphoreInitCodec_encodeResponse() { - int fileClientMessageIndex = 419; + int fileClientMessageIndex = 413; ClientMessage encoded = SemaphoreInitCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3696,7 +3650,7 @@ public void test_SemaphoreInitCodec_encodeResponse() { @Test public void test_SemaphoreAcquireCodec_decodeRequest() { - int fileClientMessageIndex = 420; + int fileClientMessageIndex = 414; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreAcquireCodec.RequestParameters parameters = SemaphoreAcquireCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3710,7 +3664,7 @@ public void test_SemaphoreAcquireCodec_decodeRequest() { @Test public void test_SemaphoreAcquireCodec_encodeResponse() { - int fileClientMessageIndex = 421; + int fileClientMessageIndex = 415; ClientMessage encoded = SemaphoreAcquireCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3718,7 +3672,7 @@ public void test_SemaphoreAcquireCodec_encodeResponse() { @Test public void test_SemaphoreReleaseCodec_decodeRequest() { - int fileClientMessageIndex = 422; + int fileClientMessageIndex = 416; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreReleaseCodec.RequestParameters parameters = SemaphoreReleaseCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3731,7 +3685,7 @@ public void test_SemaphoreReleaseCodec_decodeRequest() { @Test public void test_SemaphoreReleaseCodec_encodeResponse() { - int fileClientMessageIndex = 423; + int fileClientMessageIndex = 417; ClientMessage encoded = SemaphoreReleaseCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3739,7 +3693,7 @@ public void test_SemaphoreReleaseCodec_encodeResponse() { @Test public void test_SemaphoreDrainCodec_decodeRequest() { - int fileClientMessageIndex = 424; + int fileClientMessageIndex = 418; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreDrainCodec.RequestParameters parameters = SemaphoreDrainCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3751,7 +3705,7 @@ public void test_SemaphoreDrainCodec_decodeRequest() { @Test public void test_SemaphoreDrainCodec_encodeResponse() { - int fileClientMessageIndex = 425; + int fileClientMessageIndex = 419; ClientMessage encoded = SemaphoreDrainCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3759,7 +3713,7 @@ public void test_SemaphoreDrainCodec_encodeResponse() { @Test public void test_SemaphoreChangeCodec_decodeRequest() { - int fileClientMessageIndex = 426; + int fileClientMessageIndex = 420; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreChangeCodec.RequestParameters parameters = SemaphoreChangeCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3772,7 +3726,7 @@ public void test_SemaphoreChangeCodec_decodeRequest() { @Test public void test_SemaphoreChangeCodec_encodeResponse() { - int fileClientMessageIndex = 427; + int fileClientMessageIndex = 421; ClientMessage encoded = SemaphoreChangeCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3780,7 +3734,7 @@ public void test_SemaphoreChangeCodec_encodeResponse() { @Test public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { - int fileClientMessageIndex = 428; + int fileClientMessageIndex = 422; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SemaphoreAvailablePermitsCodec.RequestParameters parameters = SemaphoreAvailablePermitsCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -3789,7 +3743,7 @@ public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { @Test public void test_SemaphoreAvailablePermitsCodec_encodeResponse() { - int fileClientMessageIndex = 429; + int fileClientMessageIndex = 423; ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3797,14 +3751,14 @@ public void test_SemaphoreAvailablePermitsCodec_encodeResponse() { @Test public void test_SemaphoreGetSemaphoreTypeCodec_decodeRequest() { - int fileClientMessageIndex = 430; + int fileClientMessageIndex = 424; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, SemaphoreGetSemaphoreTypeCodec.decodeRequest(fromFile))); } @Test public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { - int fileClientMessageIndex = 431; + int fileClientMessageIndex = 425; ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3812,7 +3766,7 @@ public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { @Test public void test_ReplicatedMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 432; + int fileClientMessageIndex = 426; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapPutCodec.RequestParameters parameters = ReplicatedMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3823,7 +3777,7 @@ public void test_ReplicatedMapPutCodec_decodeRequest() { @Test public void test_ReplicatedMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 433; + int fileClientMessageIndex = 427; ClientMessage encoded = ReplicatedMapPutCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3831,14 +3785,14 @@ public void test_ReplicatedMapPutCodec_encodeResponse() { @Test public void test_ReplicatedMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 434; + int fileClientMessageIndex = 428; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapSizeCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 435; + int fileClientMessageIndex = 429; ClientMessage encoded = ReplicatedMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3846,14 +3800,14 @@ public void test_ReplicatedMapSizeCodec_encodeResponse() { @Test public void test_ReplicatedMapIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 436; + int fileClientMessageIndex = 430; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapIsEmptyCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 437; + int fileClientMessageIndex = 431; ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3861,7 +3815,7 @@ public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { @Test public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 438; + int fileClientMessageIndex = 432; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapContainsKeyCodec.RequestParameters parameters = ReplicatedMapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3870,7 +3824,7 @@ public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { @Test public void test_ReplicatedMapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 439; + int fileClientMessageIndex = 433; ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3878,7 +3832,7 @@ public void test_ReplicatedMapContainsKeyCodec_encodeResponse() { @Test public void test_ReplicatedMapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 440; + int fileClientMessageIndex = 434; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapContainsValueCodec.RequestParameters parameters = ReplicatedMapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3887,7 +3841,7 @@ public void test_ReplicatedMapContainsValueCodec_decodeRequest() { @Test public void test_ReplicatedMapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 441; + int fileClientMessageIndex = 435; ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3895,7 +3849,7 @@ public void test_ReplicatedMapContainsValueCodec_encodeResponse() { @Test public void test_ReplicatedMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 442; + int fileClientMessageIndex = 436; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapGetCodec.RequestParameters parameters = ReplicatedMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3904,7 +3858,7 @@ public void test_ReplicatedMapGetCodec_decodeRequest() { @Test public void test_ReplicatedMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 443; + int fileClientMessageIndex = 437; ClientMessage encoded = ReplicatedMapGetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3912,7 +3866,7 @@ public void test_ReplicatedMapGetCodec_encodeResponse() { @Test public void test_ReplicatedMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 444; + int fileClientMessageIndex = 438; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapRemoveCodec.RequestParameters parameters = ReplicatedMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3921,7 +3875,7 @@ public void test_ReplicatedMapRemoveCodec_decodeRequest() { @Test public void test_ReplicatedMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 445; + int fileClientMessageIndex = 439; ClientMessage encoded = ReplicatedMapRemoveCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3929,7 +3883,7 @@ public void test_ReplicatedMapRemoveCodec_encodeResponse() { @Test public void test_ReplicatedMapPutAllCodec_decodeRequest() { - int fileClientMessageIndex = 446; + int fileClientMessageIndex = 440; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapPutAllCodec.RequestParameters parameters = ReplicatedMapPutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3938,7 +3892,7 @@ public void test_ReplicatedMapPutAllCodec_decodeRequest() { @Test public void test_ReplicatedMapPutAllCodec_encodeResponse() { - int fileClientMessageIndex = 447; + int fileClientMessageIndex = 441; ClientMessage encoded = ReplicatedMapPutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3946,14 +3900,14 @@ public void test_ReplicatedMapPutAllCodec_encodeResponse() { @Test public void test_ReplicatedMapClearCodec_decodeRequest() { - int fileClientMessageIndex = 448; + int fileClientMessageIndex = 442; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapClearCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapClearCodec_encodeResponse() { - int fileClientMessageIndex = 449; + int fileClientMessageIndex = 443; ClientMessage encoded = ReplicatedMapClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3961,7 +3915,7 @@ public void test_ReplicatedMapClearCodec_encodeResponse() { @Test public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 450; + int fileClientMessageIndex = 444; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3972,7 +3926,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequ @Test public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 451; + int fileClientMessageIndex = 445; ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -3980,7 +3934,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeResp @Test public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 452; + int fileClientMessageIndex = 446; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -3988,7 +3942,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntr @Test public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 453; + int fileClientMessageIndex = 447; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerWithPredicateCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -3998,7 +3952,7 @@ public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_decodeRequest() @Test public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 454; + int fileClientMessageIndex = 448; ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4006,7 +3960,7 @@ public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeResponse( @Test public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { - int fileClientMessageIndex = 455; + int fileClientMessageIndex = 449; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4014,7 +3968,7 @@ public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEven @Test public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeRequest() { - int fileClientMessageIndex = 456; + int fileClientMessageIndex = 450; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerToKeyCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerToKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4024,7 +3978,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyCodec_decodeRequest() { @Test public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeResponse() { - int fileClientMessageIndex = 457; + int fileClientMessageIndex = 451; ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4032,7 +3986,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeResponse() { @Test public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { - int fileClientMessageIndex = 458; + int fileClientMessageIndex = 452; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4040,7 +3994,7 @@ public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { @Test public void test_ReplicatedMapAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 459; + int fileClientMessageIndex = 453; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4049,7 +4003,7 @@ public void test_ReplicatedMapAddEntryListenerCodec_decodeRequest() { @Test public void test_ReplicatedMapAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 460; + int fileClientMessageIndex = 454; ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4057,7 +4011,7 @@ public void test_ReplicatedMapAddEntryListenerCodec_encodeResponse() { @Test public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 461; + int fileClientMessageIndex = 455; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4065,7 +4019,7 @@ public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { @Test public void test_ReplicatedMapRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 462; + int fileClientMessageIndex = 456; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapRemoveEntryListenerCodec.RequestParameters parameters = ReplicatedMapRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4074,7 +4028,7 @@ public void test_ReplicatedMapRemoveEntryListenerCodec_decodeRequest() { @Test public void test_ReplicatedMapRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 463; + int fileClientMessageIndex = 457; ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4082,14 +4036,14 @@ public void test_ReplicatedMapRemoveEntryListenerCodec_encodeResponse() { @Test public void test_ReplicatedMapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 464; + int fileClientMessageIndex = 458; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapKeySetCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 465; + int fileClientMessageIndex = 459; ClientMessage encoded = ReplicatedMapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4097,14 +4051,14 @@ public void test_ReplicatedMapKeySetCodec_encodeResponse() { @Test public void test_ReplicatedMapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 466; + int fileClientMessageIndex = 460; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapValuesCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 467; + int fileClientMessageIndex = 461; ClientMessage encoded = ReplicatedMapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4112,14 +4066,14 @@ public void test_ReplicatedMapValuesCodec_encodeResponse() { @Test public void test_ReplicatedMapEntrySetCodec_decodeRequest() { - int fileClientMessageIndex = 468; + int fileClientMessageIndex = 462; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ReplicatedMapEntrySetCodec.decodeRequest(fromFile))); } @Test public void test_ReplicatedMapEntrySetCodec_encodeResponse() { - int fileClientMessageIndex = 469; + int fileClientMessageIndex = 463; ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4127,7 +4081,7 @@ public void test_ReplicatedMapEntrySetCodec_encodeResponse() { @Test public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 470; + int fileClientMessageIndex = 464; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ReplicatedMapAddNearCacheEntryListenerCodec.RequestParameters parameters = ReplicatedMapAddNearCacheEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4137,7 +4091,7 @@ public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { @Test public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 471; + int fileClientMessageIndex = 465; ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4145,7 +4099,7 @@ public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeResponse() { @Test public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() { - int fileClientMessageIndex = 472; + int fileClientMessageIndex = 466; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeEntryEvent(aData, aData, aData, aData, anInt, aUUID, anInt); compareClientMessages(fromFile, encoded); @@ -4153,7 +4107,7 @@ public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() @Test public void test_TransactionalMapContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 473; + int fileClientMessageIndex = 467; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapContainsKeyCodec.RequestParameters parameters = TransactionalMapContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4164,7 +4118,7 @@ public void test_TransactionalMapContainsKeyCodec_decodeRequest() { @Test public void test_TransactionalMapContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 474; + int fileClientMessageIndex = 468; ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4172,7 +4126,7 @@ public void test_TransactionalMapContainsKeyCodec_encodeResponse() { @Test public void test_TransactionalMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 475; + int fileClientMessageIndex = 469; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapGetCodec.RequestParameters parameters = TransactionalMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4183,7 +4137,7 @@ public void test_TransactionalMapGetCodec_decodeRequest() { @Test public void test_TransactionalMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 476; + int fileClientMessageIndex = 470; ClientMessage encoded = TransactionalMapGetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4191,7 +4145,7 @@ public void test_TransactionalMapGetCodec_encodeResponse() { @Test public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { - int fileClientMessageIndex = 477; + int fileClientMessageIndex = 471; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapGetForUpdateCodec.RequestParameters parameters = TransactionalMapGetForUpdateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4202,7 +4156,7 @@ public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { @Test public void test_TransactionalMapGetForUpdateCodec_encodeResponse() { - int fileClientMessageIndex = 478; + int fileClientMessageIndex = 472; ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4210,7 +4164,7 @@ public void test_TransactionalMapGetForUpdateCodec_encodeResponse() { @Test public void test_TransactionalMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 479; + int fileClientMessageIndex = 473; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapSizeCodec.RequestParameters parameters = TransactionalMapSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4220,7 +4174,7 @@ public void test_TransactionalMapSizeCodec_decodeRequest() { @Test public void test_TransactionalMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 480; + int fileClientMessageIndex = 474; ClientMessage encoded = TransactionalMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4228,7 +4182,7 @@ public void test_TransactionalMapSizeCodec_encodeResponse() { @Test public void test_TransactionalMapIsEmptyCodec_decodeRequest() { - int fileClientMessageIndex = 481; + int fileClientMessageIndex = 475; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapIsEmptyCodec.RequestParameters parameters = TransactionalMapIsEmptyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4238,7 +4192,7 @@ public void test_TransactionalMapIsEmptyCodec_decodeRequest() { @Test public void test_TransactionalMapIsEmptyCodec_encodeResponse() { - int fileClientMessageIndex = 482; + int fileClientMessageIndex = 476; ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4246,7 +4200,7 @@ public void test_TransactionalMapIsEmptyCodec_encodeResponse() { @Test public void test_TransactionalMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 483; + int fileClientMessageIndex = 477; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapPutCodec.RequestParameters parameters = TransactionalMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4259,7 +4213,7 @@ public void test_TransactionalMapPutCodec_decodeRequest() { @Test public void test_TransactionalMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 484; + int fileClientMessageIndex = 478; ClientMessage encoded = TransactionalMapPutCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4267,7 +4221,7 @@ public void test_TransactionalMapPutCodec_encodeResponse() { @Test public void test_TransactionalMapSetCodec_decodeRequest() { - int fileClientMessageIndex = 485; + int fileClientMessageIndex = 479; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapSetCodec.RequestParameters parameters = TransactionalMapSetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4279,7 +4233,7 @@ public void test_TransactionalMapSetCodec_decodeRequest() { @Test public void test_TransactionalMapSetCodec_encodeResponse() { - int fileClientMessageIndex = 486; + int fileClientMessageIndex = 480; ClientMessage encoded = TransactionalMapSetCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4287,7 +4241,7 @@ public void test_TransactionalMapSetCodec_encodeResponse() { @Test public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { - int fileClientMessageIndex = 487; + int fileClientMessageIndex = 481; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapPutIfAbsentCodec.RequestParameters parameters = TransactionalMapPutIfAbsentCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4299,7 +4253,7 @@ public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { @Test public void test_TransactionalMapPutIfAbsentCodec_encodeResponse() { - int fileClientMessageIndex = 488; + int fileClientMessageIndex = 482; ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4307,7 +4261,7 @@ public void test_TransactionalMapPutIfAbsentCodec_encodeResponse() { @Test public void test_TransactionalMapReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 489; + int fileClientMessageIndex = 483; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapReplaceCodec.RequestParameters parameters = TransactionalMapReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4319,7 +4273,7 @@ public void test_TransactionalMapReplaceCodec_decodeRequest() { @Test public void test_TransactionalMapReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 490; + int fileClientMessageIndex = 484; ClientMessage encoded = TransactionalMapReplaceCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4327,7 +4281,7 @@ public void test_TransactionalMapReplaceCodec_encodeResponse() { @Test public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 491; + int fileClientMessageIndex = 485; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapReplaceIfSameCodec.RequestParameters parameters = TransactionalMapReplaceIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4340,7 +4294,7 @@ public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { @Test public void test_TransactionalMapReplaceIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 492; + int fileClientMessageIndex = 486; ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4348,7 +4302,7 @@ public void test_TransactionalMapReplaceIfSameCodec_encodeResponse() { @Test public void test_TransactionalMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 493; + int fileClientMessageIndex = 487; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapRemoveCodec.RequestParameters parameters = TransactionalMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4359,7 +4313,7 @@ public void test_TransactionalMapRemoveCodec_decodeRequest() { @Test public void test_TransactionalMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 494; + int fileClientMessageIndex = 488; ClientMessage encoded = TransactionalMapRemoveCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4367,7 +4321,7 @@ public void test_TransactionalMapRemoveCodec_encodeResponse() { @Test public void test_TransactionalMapDeleteCodec_decodeRequest() { - int fileClientMessageIndex = 495; + int fileClientMessageIndex = 489; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapDeleteCodec.RequestParameters parameters = TransactionalMapDeleteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4378,7 +4332,7 @@ public void test_TransactionalMapDeleteCodec_decodeRequest() { @Test public void test_TransactionalMapDeleteCodec_encodeResponse() { - int fileClientMessageIndex = 496; + int fileClientMessageIndex = 490; ClientMessage encoded = TransactionalMapDeleteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4386,7 +4340,7 @@ public void test_TransactionalMapDeleteCodec_encodeResponse() { @Test public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { - int fileClientMessageIndex = 497; + int fileClientMessageIndex = 491; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapRemoveIfSameCodec.RequestParameters parameters = TransactionalMapRemoveIfSameCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4398,7 +4352,7 @@ public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { @Test public void test_TransactionalMapRemoveIfSameCodec_encodeResponse() { - int fileClientMessageIndex = 498; + int fileClientMessageIndex = 492; ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4406,7 +4360,7 @@ public void test_TransactionalMapRemoveIfSameCodec_encodeResponse() { @Test public void test_TransactionalMapKeySetCodec_decodeRequest() { - int fileClientMessageIndex = 499; + int fileClientMessageIndex = 493; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapKeySetCodec.RequestParameters parameters = TransactionalMapKeySetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4416,7 +4370,7 @@ public void test_TransactionalMapKeySetCodec_decodeRequest() { @Test public void test_TransactionalMapKeySetCodec_encodeResponse() { - int fileClientMessageIndex = 500; + int fileClientMessageIndex = 494; ClientMessage encoded = TransactionalMapKeySetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4424,7 +4378,7 @@ public void test_TransactionalMapKeySetCodec_encodeResponse() { @Test public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 501; + int fileClientMessageIndex = 495; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapKeySetWithPredicateCodec.RequestParameters parameters = TransactionalMapKeySetWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4435,7 +4389,7 @@ public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { @Test public void test_TransactionalMapKeySetWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 502; + int fileClientMessageIndex = 496; ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4443,7 +4397,7 @@ public void test_TransactionalMapKeySetWithPredicateCodec_encodeResponse() { @Test public void test_TransactionalMapValuesCodec_decodeRequest() { - int fileClientMessageIndex = 503; + int fileClientMessageIndex = 497; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapValuesCodec.RequestParameters parameters = TransactionalMapValuesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4453,7 +4407,7 @@ public void test_TransactionalMapValuesCodec_decodeRequest() { @Test public void test_TransactionalMapValuesCodec_encodeResponse() { - int fileClientMessageIndex = 504; + int fileClientMessageIndex = 498; ClientMessage encoded = TransactionalMapValuesCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4461,7 +4415,7 @@ public void test_TransactionalMapValuesCodec_encodeResponse() { @Test public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { - int fileClientMessageIndex = 505; + int fileClientMessageIndex = 499; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapValuesWithPredicateCodec.RequestParameters parameters = TransactionalMapValuesWithPredicateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4472,7 +4426,7 @@ public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { @Test public void test_TransactionalMapValuesWithPredicateCodec_encodeResponse() { - int fileClientMessageIndex = 506; + int fileClientMessageIndex = 500; ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4480,7 +4434,7 @@ public void test_TransactionalMapValuesWithPredicateCodec_encodeResponse() { @Test public void test_TransactionalMapContainsValueCodec_decodeRequest() { - int fileClientMessageIndex = 507; + int fileClientMessageIndex = 501; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMapContainsValueCodec.RequestParameters parameters = TransactionalMapContainsValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4491,7 +4445,7 @@ public void test_TransactionalMapContainsValueCodec_decodeRequest() { @Test public void test_TransactionalMapContainsValueCodec_encodeResponse() { - int fileClientMessageIndex = 508; + int fileClientMessageIndex = 502; ClientMessage encoded = TransactionalMapContainsValueCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4499,7 +4453,7 @@ public void test_TransactionalMapContainsValueCodec_encodeResponse() { @Test public void test_TransactionalMultiMapPutCodec_decodeRequest() { - int fileClientMessageIndex = 509; + int fileClientMessageIndex = 503; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapPutCodec.RequestParameters parameters = TransactionalMultiMapPutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4511,7 +4465,7 @@ public void test_TransactionalMultiMapPutCodec_decodeRequest() { @Test public void test_TransactionalMultiMapPutCodec_encodeResponse() { - int fileClientMessageIndex = 510; + int fileClientMessageIndex = 504; ClientMessage encoded = TransactionalMultiMapPutCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4519,7 +4473,7 @@ public void test_TransactionalMultiMapPutCodec_encodeResponse() { @Test public void test_TransactionalMultiMapGetCodec_decodeRequest() { - int fileClientMessageIndex = 511; + int fileClientMessageIndex = 505; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapGetCodec.RequestParameters parameters = TransactionalMultiMapGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4530,7 +4484,7 @@ public void test_TransactionalMultiMapGetCodec_decodeRequest() { @Test public void test_TransactionalMultiMapGetCodec_encodeResponse() { - int fileClientMessageIndex = 512; + int fileClientMessageIndex = 506; ClientMessage encoded = TransactionalMultiMapGetCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4538,7 +4492,7 @@ public void test_TransactionalMultiMapGetCodec_encodeResponse() { @Test public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 513; + int fileClientMessageIndex = 507; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapRemoveCodec.RequestParameters parameters = TransactionalMultiMapRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4549,7 +4503,7 @@ public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { @Test public void test_TransactionalMultiMapRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 514; + int fileClientMessageIndex = 508; ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4557,7 +4511,7 @@ public void test_TransactionalMultiMapRemoveCodec_encodeResponse() { @Test public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { - int fileClientMessageIndex = 515; + int fileClientMessageIndex = 509; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapRemoveEntryCodec.RequestParameters parameters = TransactionalMultiMapRemoveEntryCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4569,7 +4523,7 @@ public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { @Test public void test_TransactionalMultiMapRemoveEntryCodec_encodeResponse() { - int fileClientMessageIndex = 516; + int fileClientMessageIndex = 510; ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4577,7 +4531,7 @@ public void test_TransactionalMultiMapRemoveEntryCodec_encodeResponse() { @Test public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { - int fileClientMessageIndex = 517; + int fileClientMessageIndex = 511; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapValueCountCodec.RequestParameters parameters = TransactionalMultiMapValueCountCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4588,7 +4542,7 @@ public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { @Test public void test_TransactionalMultiMapValueCountCodec_encodeResponse() { - int fileClientMessageIndex = 518; + int fileClientMessageIndex = 512; ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4596,7 +4550,7 @@ public void test_TransactionalMultiMapValueCountCodec_encodeResponse() { @Test public void test_TransactionalMultiMapSizeCodec_decodeRequest() { - int fileClientMessageIndex = 519; + int fileClientMessageIndex = 513; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalMultiMapSizeCodec.RequestParameters parameters = TransactionalMultiMapSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4606,7 +4560,7 @@ public void test_TransactionalMultiMapSizeCodec_decodeRequest() { @Test public void test_TransactionalMultiMapSizeCodec_encodeResponse() { - int fileClientMessageIndex = 520; + int fileClientMessageIndex = 514; ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4614,7 +4568,7 @@ public void test_TransactionalMultiMapSizeCodec_encodeResponse() { @Test public void test_TransactionalSetAddCodec_decodeRequest() { - int fileClientMessageIndex = 521; + int fileClientMessageIndex = 515; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalSetAddCodec.RequestParameters parameters = TransactionalSetAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4625,7 +4579,7 @@ public void test_TransactionalSetAddCodec_decodeRequest() { @Test public void test_TransactionalSetAddCodec_encodeResponse() { - int fileClientMessageIndex = 522; + int fileClientMessageIndex = 516; ClientMessage encoded = TransactionalSetAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4633,7 +4587,7 @@ public void test_TransactionalSetAddCodec_encodeResponse() { @Test public void test_TransactionalSetRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 523; + int fileClientMessageIndex = 517; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalSetRemoveCodec.RequestParameters parameters = TransactionalSetRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4644,7 +4598,7 @@ public void test_TransactionalSetRemoveCodec_decodeRequest() { @Test public void test_TransactionalSetRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 524; + int fileClientMessageIndex = 518; ClientMessage encoded = TransactionalSetRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4652,7 +4606,7 @@ public void test_TransactionalSetRemoveCodec_encodeResponse() { @Test public void test_TransactionalSetSizeCodec_decodeRequest() { - int fileClientMessageIndex = 525; + int fileClientMessageIndex = 519; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalSetSizeCodec.RequestParameters parameters = TransactionalSetSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4662,7 +4616,7 @@ public void test_TransactionalSetSizeCodec_decodeRequest() { @Test public void test_TransactionalSetSizeCodec_encodeResponse() { - int fileClientMessageIndex = 526; + int fileClientMessageIndex = 520; ClientMessage encoded = TransactionalSetSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4670,7 +4624,7 @@ public void test_TransactionalSetSizeCodec_encodeResponse() { @Test public void test_TransactionalListAddCodec_decodeRequest() { - int fileClientMessageIndex = 527; + int fileClientMessageIndex = 521; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalListAddCodec.RequestParameters parameters = TransactionalListAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4681,7 +4635,7 @@ public void test_TransactionalListAddCodec_decodeRequest() { @Test public void test_TransactionalListAddCodec_encodeResponse() { - int fileClientMessageIndex = 528; + int fileClientMessageIndex = 522; ClientMessage encoded = TransactionalListAddCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4689,7 +4643,7 @@ public void test_TransactionalListAddCodec_encodeResponse() { @Test public void test_TransactionalListRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 529; + int fileClientMessageIndex = 523; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalListRemoveCodec.RequestParameters parameters = TransactionalListRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4700,7 +4654,7 @@ public void test_TransactionalListRemoveCodec_decodeRequest() { @Test public void test_TransactionalListRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 530; + int fileClientMessageIndex = 524; ClientMessage encoded = TransactionalListRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4708,7 +4662,7 @@ public void test_TransactionalListRemoveCodec_encodeResponse() { @Test public void test_TransactionalListSizeCodec_decodeRequest() { - int fileClientMessageIndex = 531; + int fileClientMessageIndex = 525; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalListSizeCodec.RequestParameters parameters = TransactionalListSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4718,7 +4672,7 @@ public void test_TransactionalListSizeCodec_decodeRequest() { @Test public void test_TransactionalListSizeCodec_encodeResponse() { - int fileClientMessageIndex = 532; + int fileClientMessageIndex = 526; ClientMessage encoded = TransactionalListSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4726,7 +4680,7 @@ public void test_TransactionalListSizeCodec_encodeResponse() { @Test public void test_TransactionalQueueOfferCodec_decodeRequest() { - int fileClientMessageIndex = 533; + int fileClientMessageIndex = 527; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueueOfferCodec.RequestParameters parameters = TransactionalQueueOfferCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4738,7 +4692,7 @@ public void test_TransactionalQueueOfferCodec_decodeRequest() { @Test public void test_TransactionalQueueOfferCodec_encodeResponse() { - int fileClientMessageIndex = 534; + int fileClientMessageIndex = 528; ClientMessage encoded = TransactionalQueueOfferCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4746,7 +4700,7 @@ public void test_TransactionalQueueOfferCodec_encodeResponse() { @Test public void test_TransactionalQueueTakeCodec_decodeRequest() { - int fileClientMessageIndex = 535; + int fileClientMessageIndex = 529; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueueTakeCodec.RequestParameters parameters = TransactionalQueueTakeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4756,7 +4710,7 @@ public void test_TransactionalQueueTakeCodec_decodeRequest() { @Test public void test_TransactionalQueueTakeCodec_encodeResponse() { - int fileClientMessageIndex = 536; + int fileClientMessageIndex = 530; ClientMessage encoded = TransactionalQueueTakeCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4764,7 +4718,7 @@ public void test_TransactionalQueueTakeCodec_encodeResponse() { @Test public void test_TransactionalQueuePollCodec_decodeRequest() { - int fileClientMessageIndex = 537; + int fileClientMessageIndex = 531; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueuePollCodec.RequestParameters parameters = TransactionalQueuePollCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4775,7 +4729,7 @@ public void test_TransactionalQueuePollCodec_decodeRequest() { @Test public void test_TransactionalQueuePollCodec_encodeResponse() { - int fileClientMessageIndex = 538; + int fileClientMessageIndex = 532; ClientMessage encoded = TransactionalQueuePollCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4783,7 +4737,7 @@ public void test_TransactionalQueuePollCodec_encodeResponse() { @Test public void test_TransactionalQueuePeekCodec_decodeRequest() { - int fileClientMessageIndex = 539; + int fileClientMessageIndex = 533; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueuePeekCodec.RequestParameters parameters = TransactionalQueuePeekCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4794,7 +4748,7 @@ public void test_TransactionalQueuePeekCodec_decodeRequest() { @Test public void test_TransactionalQueuePeekCodec_encodeResponse() { - int fileClientMessageIndex = 540; + int fileClientMessageIndex = 534; ClientMessage encoded = TransactionalQueuePeekCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4802,7 +4756,7 @@ public void test_TransactionalQueuePeekCodec_encodeResponse() { @Test public void test_TransactionalQueueSizeCodec_decodeRequest() { - int fileClientMessageIndex = 541; + int fileClientMessageIndex = 535; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionalQueueSizeCodec.RequestParameters parameters = TransactionalQueueSizeCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4812,7 +4766,7 @@ public void test_TransactionalQueueSizeCodec_decodeRequest() { @Test public void test_TransactionalQueueSizeCodec_encodeResponse() { - int fileClientMessageIndex = 542; + int fileClientMessageIndex = 536; ClientMessage encoded = TransactionalQueueSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4820,7 +4774,7 @@ public void test_TransactionalQueueSizeCodec_encodeResponse() { @Test public void test_CacheAddEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 543; + int fileClientMessageIndex = 537; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheAddEntryListenerCodec.RequestParameters parameters = CacheAddEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4829,7 +4783,7 @@ public void test_CacheAddEntryListenerCodec_decodeRequest() { @Test public void test_CacheAddEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 544; + int fileClientMessageIndex = 538; ClientMessage encoded = CacheAddEntryListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4837,7 +4791,7 @@ public void test_CacheAddEntryListenerCodec_encodeResponse() { @Test public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { - int fileClientMessageIndex = 545; + int fileClientMessageIndex = 539; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddEntryListenerCodec.encodeCacheEvent(anInt, aListOfCacheEventData, anInt); compareClientMessages(fromFile, encoded); @@ -4845,14 +4799,14 @@ public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { @Test public void test_CacheClearCodec_decodeRequest() { - int fileClientMessageIndex = 546; + int fileClientMessageIndex = 540; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheClearCodec.decodeRequest(fromFile))); } @Test public void test_CacheClearCodec_encodeResponse() { - int fileClientMessageIndex = 547; + int fileClientMessageIndex = 541; ClientMessage encoded = CacheClearCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4860,7 +4814,7 @@ public void test_CacheClearCodec_encodeResponse() { @Test public void test_CacheRemoveAllKeysCodec_decodeRequest() { - int fileClientMessageIndex = 548; + int fileClientMessageIndex = 542; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveAllKeysCodec.RequestParameters parameters = CacheRemoveAllKeysCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4870,7 +4824,7 @@ public void test_CacheRemoveAllKeysCodec_decodeRequest() { @Test public void test_CacheRemoveAllKeysCodec_encodeResponse() { - int fileClientMessageIndex = 549; + int fileClientMessageIndex = 543; ClientMessage encoded = CacheRemoveAllKeysCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4878,7 +4832,7 @@ public void test_CacheRemoveAllKeysCodec_encodeResponse() { @Test public void test_CacheRemoveAllCodec_decodeRequest() { - int fileClientMessageIndex = 550; + int fileClientMessageIndex = 544; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveAllCodec.RequestParameters parameters = CacheRemoveAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4887,7 +4841,7 @@ public void test_CacheRemoveAllCodec_decodeRequest() { @Test public void test_CacheRemoveAllCodec_encodeResponse() { - int fileClientMessageIndex = 551; + int fileClientMessageIndex = 545; ClientMessage encoded = CacheRemoveAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4895,7 +4849,7 @@ public void test_CacheRemoveAllCodec_encodeResponse() { @Test public void test_CacheContainsKeyCodec_decodeRequest() { - int fileClientMessageIndex = 552; + int fileClientMessageIndex = 546; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheContainsKeyCodec.RequestParameters parameters = CacheContainsKeyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4904,7 +4858,7 @@ public void test_CacheContainsKeyCodec_decodeRequest() { @Test public void test_CacheContainsKeyCodec_encodeResponse() { - int fileClientMessageIndex = 553; + int fileClientMessageIndex = 547; ClientMessage encoded = CacheContainsKeyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4912,7 +4866,7 @@ public void test_CacheContainsKeyCodec_encodeResponse() { @Test public void test_CacheCreateConfigCodec_decodeRequest() { - int fileClientMessageIndex = 554; + int fileClientMessageIndex = 548; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheCreateConfigCodec.RequestParameters parameters = CacheCreateConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aCacheConfigHolder, parameters.cacheConfig)); @@ -4921,7 +4875,7 @@ public void test_CacheCreateConfigCodec_decodeRequest() { @Test public void test_CacheCreateConfigCodec_encodeResponse() { - int fileClientMessageIndex = 555; + int fileClientMessageIndex = 549; ClientMessage encoded = CacheCreateConfigCodec.encodeResponse(aCacheConfigHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4929,14 +4883,14 @@ public void test_CacheCreateConfigCodec_encodeResponse() { @Test public void test_CacheDestroyCodec_decodeRequest() { - int fileClientMessageIndex = 556; + int fileClientMessageIndex = 550; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheDestroyCodec.decodeRequest(fromFile))); } @Test public void test_CacheDestroyCodec_encodeResponse() { - int fileClientMessageIndex = 557; + int fileClientMessageIndex = 551; ClientMessage encoded = CacheDestroyCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4944,7 +4898,7 @@ public void test_CacheDestroyCodec_encodeResponse() { @Test public void test_CacheEntryProcessorCodec_decodeRequest() { - int fileClientMessageIndex = 558; + int fileClientMessageIndex = 552; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheEntryProcessorCodec.RequestParameters parameters = CacheEntryProcessorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4956,7 +4910,7 @@ public void test_CacheEntryProcessorCodec_decodeRequest() { @Test public void test_CacheEntryProcessorCodec_encodeResponse() { - int fileClientMessageIndex = 559; + int fileClientMessageIndex = 553; ClientMessage encoded = CacheEntryProcessorCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4964,7 +4918,7 @@ public void test_CacheEntryProcessorCodec_encodeResponse() { @Test public void test_CacheGetAllCodec_decodeRequest() { - int fileClientMessageIndex = 560; + int fileClientMessageIndex = 554; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetAllCodec.RequestParameters parameters = CacheGetAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4974,7 +4928,7 @@ public void test_CacheGetAllCodec_decodeRequest() { @Test public void test_CacheGetAllCodec_encodeResponse() { - int fileClientMessageIndex = 561; + int fileClientMessageIndex = 555; ClientMessage encoded = CacheGetAllCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -4982,7 +4936,7 @@ public void test_CacheGetAllCodec_encodeResponse() { @Test public void test_CacheGetAndRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 562; + int fileClientMessageIndex = 556; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetAndRemoveCodec.RequestParameters parameters = CacheGetAndRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -4992,7 +4946,7 @@ public void test_CacheGetAndRemoveCodec_decodeRequest() { @Test public void test_CacheGetAndRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 563; + int fileClientMessageIndex = 557; ClientMessage encoded = CacheGetAndRemoveCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5000,7 +4954,7 @@ public void test_CacheGetAndRemoveCodec_encodeResponse() { @Test public void test_CacheGetAndReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 564; + int fileClientMessageIndex = 558; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetAndReplaceCodec.RequestParameters parameters = CacheGetAndReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5012,7 +4966,7 @@ public void test_CacheGetAndReplaceCodec_decodeRequest() { @Test public void test_CacheGetAndReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 565; + int fileClientMessageIndex = 559; ClientMessage encoded = CacheGetAndReplaceCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5020,7 +4974,7 @@ public void test_CacheGetAndReplaceCodec_encodeResponse() { @Test public void test_CacheGetConfigCodec_decodeRequest() { - int fileClientMessageIndex = 566; + int fileClientMessageIndex = 560; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetConfigCodec.RequestParameters parameters = CacheGetConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5029,7 +4983,7 @@ public void test_CacheGetConfigCodec_decodeRequest() { @Test public void test_CacheGetConfigCodec_encodeResponse() { - int fileClientMessageIndex = 567; + int fileClientMessageIndex = 561; ClientMessage encoded = CacheGetConfigCodec.encodeResponse(aCacheConfigHolder); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5037,7 +4991,7 @@ public void test_CacheGetConfigCodec_encodeResponse() { @Test public void test_CacheGetCodec_decodeRequest() { - int fileClientMessageIndex = 568; + int fileClientMessageIndex = 562; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheGetCodec.RequestParameters parameters = CacheGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5047,7 +5001,7 @@ public void test_CacheGetCodec_decodeRequest() { @Test public void test_CacheGetCodec_encodeResponse() { - int fileClientMessageIndex = 569; + int fileClientMessageIndex = 563; ClientMessage encoded = CacheGetCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5055,7 +5009,7 @@ public void test_CacheGetCodec_encodeResponse() { @Test public void test_CacheIterateCodec_decodeRequest() { - int fileClientMessageIndex = 570; + int fileClientMessageIndex = 564; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheIterateCodec.RequestParameters parameters = CacheIterateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5065,7 +5019,7 @@ public void test_CacheIterateCodec_decodeRequest() { @Test public void test_CacheIterateCodec_encodeResponse() { - int fileClientMessageIndex = 571; + int fileClientMessageIndex = 565; ClientMessage encoded = CacheIterateCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5073,7 +5027,7 @@ public void test_CacheIterateCodec_encodeResponse() { @Test public void test_CacheListenerRegistrationCodec_decodeRequest() { - int fileClientMessageIndex = 572; + int fileClientMessageIndex = 566; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheListenerRegistrationCodec.RequestParameters parameters = CacheListenerRegistrationCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5084,7 +5038,7 @@ public void test_CacheListenerRegistrationCodec_decodeRequest() { @Test public void test_CacheListenerRegistrationCodec_encodeResponse() { - int fileClientMessageIndex = 573; + int fileClientMessageIndex = 567; ClientMessage encoded = CacheListenerRegistrationCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5092,7 +5046,7 @@ public void test_CacheListenerRegistrationCodec_encodeResponse() { @Test public void test_CacheLoadAllCodec_decodeRequest() { - int fileClientMessageIndex = 574; + int fileClientMessageIndex = 568; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheLoadAllCodec.RequestParameters parameters = CacheLoadAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5102,7 +5056,7 @@ public void test_CacheLoadAllCodec_decodeRequest() { @Test public void test_CacheLoadAllCodec_encodeResponse() { - int fileClientMessageIndex = 575; + int fileClientMessageIndex = 569; ClientMessage encoded = CacheLoadAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5110,7 +5064,7 @@ public void test_CacheLoadAllCodec_encodeResponse() { @Test public void test_CacheManagementConfigCodec_decodeRequest() { - int fileClientMessageIndex = 576; + int fileClientMessageIndex = 570; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheManagementConfigCodec.RequestParameters parameters = CacheManagementConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5121,7 +5075,7 @@ public void test_CacheManagementConfigCodec_decodeRequest() { @Test public void test_CacheManagementConfigCodec_encodeResponse() { - int fileClientMessageIndex = 577; + int fileClientMessageIndex = 571; ClientMessage encoded = CacheManagementConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5129,7 +5083,7 @@ public void test_CacheManagementConfigCodec_encodeResponse() { @Test public void test_CachePutIfAbsentCodec_decodeRequest() { - int fileClientMessageIndex = 578; + int fileClientMessageIndex = 572; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CachePutIfAbsentCodec.RequestParameters parameters = CachePutIfAbsentCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5141,7 +5095,7 @@ public void test_CachePutIfAbsentCodec_decodeRequest() { @Test public void test_CachePutIfAbsentCodec_encodeResponse() { - int fileClientMessageIndex = 579; + int fileClientMessageIndex = 573; ClientMessage encoded = CachePutIfAbsentCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5149,7 +5103,7 @@ public void test_CachePutIfAbsentCodec_encodeResponse() { @Test public void test_CachePutCodec_decodeRequest() { - int fileClientMessageIndex = 580; + int fileClientMessageIndex = 574; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CachePutCodec.RequestParameters parameters = CachePutCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5162,7 +5116,7 @@ public void test_CachePutCodec_decodeRequest() { @Test public void test_CachePutCodec_encodeResponse() { - int fileClientMessageIndex = 581; + int fileClientMessageIndex = 575; ClientMessage encoded = CachePutCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5170,7 +5124,7 @@ public void test_CachePutCodec_encodeResponse() { @Test public void test_CacheRemoveEntryListenerCodec_decodeRequest() { - int fileClientMessageIndex = 582; + int fileClientMessageIndex = 576; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveEntryListenerCodec.RequestParameters parameters = CacheRemoveEntryListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5179,7 +5133,7 @@ public void test_CacheRemoveEntryListenerCodec_decodeRequest() { @Test public void test_CacheRemoveEntryListenerCodec_encodeResponse() { - int fileClientMessageIndex = 583; + int fileClientMessageIndex = 577; ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5187,7 +5141,7 @@ public void test_CacheRemoveEntryListenerCodec_encodeResponse() { @Test public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { - int fileClientMessageIndex = 584; + int fileClientMessageIndex = 578; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveInvalidationListenerCodec.RequestParameters parameters = CacheRemoveInvalidationListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5196,7 +5150,7 @@ public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { @Test public void test_CacheRemoveInvalidationListenerCodec_encodeResponse() { - int fileClientMessageIndex = 585; + int fileClientMessageIndex = 579; ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5204,7 +5158,7 @@ public void test_CacheRemoveInvalidationListenerCodec_encodeResponse() { @Test public void test_CacheRemoveCodec_decodeRequest() { - int fileClientMessageIndex = 586; + int fileClientMessageIndex = 580; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemoveCodec.RequestParameters parameters = CacheRemoveCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5215,7 +5169,7 @@ public void test_CacheRemoveCodec_decodeRequest() { @Test public void test_CacheRemoveCodec_encodeResponse() { - int fileClientMessageIndex = 587; + int fileClientMessageIndex = 581; ClientMessage encoded = CacheRemoveCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5223,7 +5177,7 @@ public void test_CacheRemoveCodec_encodeResponse() { @Test public void test_CacheReplaceCodec_decodeRequest() { - int fileClientMessageIndex = 588; + int fileClientMessageIndex = 582; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheReplaceCodec.RequestParameters parameters = CacheReplaceCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5236,7 +5190,7 @@ public void test_CacheReplaceCodec_decodeRequest() { @Test public void test_CacheReplaceCodec_encodeResponse() { - int fileClientMessageIndex = 589; + int fileClientMessageIndex = 583; ClientMessage encoded = CacheReplaceCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5244,14 +5198,14 @@ public void test_CacheReplaceCodec_encodeResponse() { @Test public void test_CacheSizeCodec_decodeRequest() { - int fileClientMessageIndex = 590; + int fileClientMessageIndex = 584; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheSizeCodec.decodeRequest(fromFile))); } @Test public void test_CacheSizeCodec_encodeResponse() { - int fileClientMessageIndex = 591; + int fileClientMessageIndex = 585; ClientMessage encoded = CacheSizeCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5259,7 +5213,7 @@ public void test_CacheSizeCodec_encodeResponse() { @Test public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 592; + int fileClientMessageIndex = 586; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheAddPartitionLostListenerCodec.RequestParameters parameters = CacheAddPartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5268,7 +5222,7 @@ public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { @Test public void test_CacheAddPartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 593; + int fileClientMessageIndex = 587; ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5276,7 +5230,7 @@ public void test_CacheAddPartitionLostListenerCodec_encodeResponse() { @Test public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEvent() { - int fileClientMessageIndex = 594; + int fileClientMessageIndex = 588; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeCachePartitionLostEvent(anInt, aUUID); compareClientMessages(fromFile, encoded); @@ -5284,7 +5238,7 @@ public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEven @Test public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { - int fileClientMessageIndex = 595; + int fileClientMessageIndex = 589; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheRemovePartitionLostListenerCodec.RequestParameters parameters = CacheRemovePartitionLostListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5293,7 +5247,7 @@ public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { @Test public void test_CacheRemovePartitionLostListenerCodec_encodeResponse() { - int fileClientMessageIndex = 596; + int fileClientMessageIndex = 590; ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5301,7 +5255,7 @@ public void test_CacheRemovePartitionLostListenerCodec_encodeResponse() { @Test public void test_CachePutAllCodec_decodeRequest() { - int fileClientMessageIndex = 597; + int fileClientMessageIndex = 591; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CachePutAllCodec.RequestParameters parameters = CachePutAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5312,7 +5266,7 @@ public void test_CachePutAllCodec_decodeRequest() { @Test public void test_CachePutAllCodec_encodeResponse() { - int fileClientMessageIndex = 598; + int fileClientMessageIndex = 592; ClientMessage encoded = CachePutAllCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5320,7 +5274,7 @@ public void test_CachePutAllCodec_encodeResponse() { @Test public void test_CacheIterateEntriesCodec_decodeRequest() { - int fileClientMessageIndex = 599; + int fileClientMessageIndex = 593; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheIterateEntriesCodec.RequestParameters parameters = CacheIterateEntriesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5330,7 +5284,7 @@ public void test_CacheIterateEntriesCodec_decodeRequest() { @Test public void test_CacheIterateEntriesCodec_encodeResponse() { - int fileClientMessageIndex = 600; + int fileClientMessageIndex = 594; ClientMessage encoded = CacheIterateEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5338,7 +5292,7 @@ public void test_CacheIterateEntriesCodec_encodeResponse() { @Test public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { - int fileClientMessageIndex = 601; + int fileClientMessageIndex = 595; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheAddNearCacheInvalidationListenerCodec.RequestParameters parameters = CacheAddNearCacheInvalidationListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5347,7 +5301,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { @Test public void test_CacheAddNearCacheInvalidationListenerCodec_encodeResponse() { - int fileClientMessageIndex = 602; + int fileClientMessageIndex = 596; ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5355,7 +5309,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_encodeResponse() { @Test public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidationEvent() { - int fileClientMessageIndex = 603; + int fileClientMessageIndex = 597; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheInvalidationEvent(aString, aData, aUUID, aUUID, aLong); compareClientMessages(fromFile, encoded); @@ -5363,7 +5317,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidat @Test public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheBatchInvalidationEvent() { - int fileClientMessageIndex = 604; + int fileClientMessageIndex = 598; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeCacheBatchInvalidationEvent(aString, aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); compareClientMessages(fromFile, encoded); @@ -5371,7 +5325,7 @@ public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheBatchInva @Test public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeRequest() { - int fileClientMessageIndex = 605; + int fileClientMessageIndex = 599; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheFetchNearCacheInvalidationMetadataCodec.RequestParameters parameters = CacheFetchNearCacheInvalidationMetadataCodec.decodeRequest(fromFile); assertTrue(isEqual(aListOfStrings, parameters.names)); @@ -5380,7 +5334,7 @@ public void test_CacheFetchNearCacheInvalidationMetadataCodec_decodeRequest() { @Test public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeResponse() { - int fileClientMessageIndex = 606; + int fileClientMessageIndex = 600; ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5388,14 +5342,14 @@ public void test_CacheFetchNearCacheInvalidationMetadataCodec_encodeResponse() { @Test public void test_CacheEventJournalSubscribeCodec_decodeRequest() { - int fileClientMessageIndex = 607; + int fileClientMessageIndex = 601; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CacheEventJournalSubscribeCodec.decodeRequest(fromFile))); } @Test public void test_CacheEventJournalSubscribeCodec_encodeResponse() { - int fileClientMessageIndex = 608; + int fileClientMessageIndex = 602; ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeResponse(aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5403,7 +5357,7 @@ public void test_CacheEventJournalSubscribeCodec_encodeResponse() { @Test public void test_CacheEventJournalReadCodec_decodeRequest() { - int fileClientMessageIndex = 609; + int fileClientMessageIndex = 603; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheEventJournalReadCodec.RequestParameters parameters = CacheEventJournalReadCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5416,7 +5370,7 @@ public void test_CacheEventJournalReadCodec_decodeRequest() { @Test public void test_CacheEventJournalReadCodec_encodeResponse() { - int fileClientMessageIndex = 610; + int fileClientMessageIndex = 604; ClientMessage encoded = CacheEventJournalReadCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5424,7 +5378,7 @@ public void test_CacheEventJournalReadCodec_encodeResponse() { @Test public void test_CacheSetExpiryPolicyCodec_decodeRequest() { - int fileClientMessageIndex = 611; + int fileClientMessageIndex = 605; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CacheSetExpiryPolicyCodec.RequestParameters parameters = CacheSetExpiryPolicyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5434,7 +5388,7 @@ public void test_CacheSetExpiryPolicyCodec_decodeRequest() { @Test public void test_CacheSetExpiryPolicyCodec_encodeResponse() { - int fileClientMessageIndex = 612; + int fileClientMessageIndex = 606; ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5442,14 +5396,14 @@ public void test_CacheSetExpiryPolicyCodec_encodeResponse() { @Test public void test_XATransactionClearRemoteCodec_decodeRequest() { - int fileClientMessageIndex = 613; + int fileClientMessageIndex = 607; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anXid, XATransactionClearRemoteCodec.decodeRequest(fromFile))); } @Test public void test_XATransactionClearRemoteCodec_encodeResponse() { - int fileClientMessageIndex = 614; + int fileClientMessageIndex = 608; ClientMessage encoded = XATransactionClearRemoteCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5457,12 +5411,12 @@ public void test_XATransactionClearRemoteCodec_encodeResponse() { @Test public void test_XATransactionCollectTransactionsCodec_decodeRequest() { - int fileClientMessageIndex = 615; + int fileClientMessageIndex = 609; } @Test public void test_XATransactionCollectTransactionsCodec_encodeResponse() { - int fileClientMessageIndex = 616; + int fileClientMessageIndex = 610; ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeResponse(aListOfXids); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5470,7 +5424,7 @@ public void test_XATransactionCollectTransactionsCodec_encodeResponse() { @Test public void test_XATransactionFinalizeCodec_decodeRequest() { - int fileClientMessageIndex = 617; + int fileClientMessageIndex = 611; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); XATransactionFinalizeCodec.RequestParameters parameters = XATransactionFinalizeCodec.decodeRequest(fromFile); assertTrue(isEqual(anXid, parameters.xid)); @@ -5479,7 +5433,7 @@ public void test_XATransactionFinalizeCodec_decodeRequest() { @Test public void test_XATransactionFinalizeCodec_encodeResponse() { - int fileClientMessageIndex = 618; + int fileClientMessageIndex = 612; ClientMessage encoded = XATransactionFinalizeCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5487,7 +5441,7 @@ public void test_XATransactionFinalizeCodec_encodeResponse() { @Test public void test_XATransactionCommitCodec_decodeRequest() { - int fileClientMessageIndex = 619; + int fileClientMessageIndex = 613; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); XATransactionCommitCodec.RequestParameters parameters = XATransactionCommitCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.transactionId)); @@ -5496,7 +5450,7 @@ public void test_XATransactionCommitCodec_decodeRequest() { @Test public void test_XATransactionCommitCodec_encodeResponse() { - int fileClientMessageIndex = 620; + int fileClientMessageIndex = 614; ClientMessage encoded = XATransactionCommitCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5504,7 +5458,7 @@ public void test_XATransactionCommitCodec_encodeResponse() { @Test public void test_XATransactionCreateCodec_decodeRequest() { - int fileClientMessageIndex = 621; + int fileClientMessageIndex = 615; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); XATransactionCreateCodec.RequestParameters parameters = XATransactionCreateCodec.decodeRequest(fromFile); assertTrue(isEqual(anXid, parameters.xid)); @@ -5513,7 +5467,7 @@ public void test_XATransactionCreateCodec_decodeRequest() { @Test public void test_XATransactionCreateCodec_encodeResponse() { - int fileClientMessageIndex = 622; + int fileClientMessageIndex = 616; ClientMessage encoded = XATransactionCreateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5521,14 +5475,14 @@ public void test_XATransactionCreateCodec_encodeResponse() { @Test public void test_XATransactionPrepareCodec_decodeRequest() { - int fileClientMessageIndex = 623; + int fileClientMessageIndex = 617; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, XATransactionPrepareCodec.decodeRequest(fromFile))); } @Test public void test_XATransactionPrepareCodec_encodeResponse() { - int fileClientMessageIndex = 624; + int fileClientMessageIndex = 618; ClientMessage encoded = XATransactionPrepareCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5536,14 +5490,14 @@ public void test_XATransactionPrepareCodec_encodeResponse() { @Test public void test_XATransactionRollbackCodec_decodeRequest() { - int fileClientMessageIndex = 625; + int fileClientMessageIndex = 619; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, XATransactionRollbackCodec.decodeRequest(fromFile))); } @Test public void test_XATransactionRollbackCodec_encodeResponse() { - int fileClientMessageIndex = 626; + int fileClientMessageIndex = 620; ClientMessage encoded = XATransactionRollbackCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5551,7 +5505,7 @@ public void test_XATransactionRollbackCodec_encodeResponse() { @Test public void test_TransactionCommitCodec_decodeRequest() { - int fileClientMessageIndex = 627; + int fileClientMessageIndex = 621; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionCommitCodec.RequestParameters parameters = TransactionCommitCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.transactionId)); @@ -5560,7 +5514,7 @@ public void test_TransactionCommitCodec_decodeRequest() { @Test public void test_TransactionCommitCodec_encodeResponse() { - int fileClientMessageIndex = 628; + int fileClientMessageIndex = 622; ClientMessage encoded = TransactionCommitCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5568,7 +5522,7 @@ public void test_TransactionCommitCodec_encodeResponse() { @Test public void test_TransactionCreateCodec_decodeRequest() { - int fileClientMessageIndex = 629; + int fileClientMessageIndex = 623; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionCreateCodec.RequestParameters parameters = TransactionCreateCodec.decodeRequest(fromFile); assertTrue(isEqual(aLong, parameters.timeout)); @@ -5579,7 +5533,7 @@ public void test_TransactionCreateCodec_decodeRequest() { @Test public void test_TransactionCreateCodec_encodeResponse() { - int fileClientMessageIndex = 630; + int fileClientMessageIndex = 624; ClientMessage encoded = TransactionCreateCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5587,7 +5541,7 @@ public void test_TransactionCreateCodec_encodeResponse() { @Test public void test_TransactionRollbackCodec_decodeRequest() { - int fileClientMessageIndex = 631; + int fileClientMessageIndex = 625; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); TransactionRollbackCodec.RequestParameters parameters = TransactionRollbackCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.transactionId)); @@ -5596,7 +5550,7 @@ public void test_TransactionRollbackCodec_decodeRequest() { @Test public void test_TransactionRollbackCodec_encodeResponse() { - int fileClientMessageIndex = 632; + int fileClientMessageIndex = 626; ClientMessage encoded = TransactionRollbackCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5604,7 +5558,7 @@ public void test_TransactionRollbackCodec_encodeResponse() { @Test public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { - int fileClientMessageIndex = 633; + int fileClientMessageIndex = 627; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryPublisherCreateWithValueCodec.RequestParameters parameters = ContinuousQueryPublisherCreateWithValueCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5619,7 +5573,7 @@ public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { @Test public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeResponse() { - int fileClientMessageIndex = 634; + int fileClientMessageIndex = 628; ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeResponse(aListOfDataToData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5627,7 +5581,7 @@ public void test_ContinuousQueryPublisherCreateWithValueCodec_encodeResponse() { @Test public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { - int fileClientMessageIndex = 635; + int fileClientMessageIndex = 629; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryPublisherCreateCodec.RequestParameters parameters = ContinuousQueryPublisherCreateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5642,7 +5596,7 @@ public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { @Test public void test_ContinuousQueryPublisherCreateCodec_encodeResponse() { - int fileClientMessageIndex = 636; + int fileClientMessageIndex = 630; ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeResponse(aListOfData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5650,7 +5604,7 @@ public void test_ContinuousQueryPublisherCreateCodec_encodeResponse() { @Test public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { - int fileClientMessageIndex = 637; + int fileClientMessageIndex = 631; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryMadePublishableCodec.RequestParameters parameters = ContinuousQueryMadePublishableCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5659,7 +5613,7 @@ public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { @Test public void test_ContinuousQueryMadePublishableCodec_encodeResponse() { - int fileClientMessageIndex = 638; + int fileClientMessageIndex = 632; ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5667,7 +5621,7 @@ public void test_ContinuousQueryMadePublishableCodec_encodeResponse() { @Test public void test_ContinuousQueryAddListenerCodec_decodeRequest() { - int fileClientMessageIndex = 639; + int fileClientMessageIndex = 633; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryAddListenerCodec.RequestParameters parameters = ContinuousQueryAddListenerCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.listenerName)); @@ -5676,7 +5630,7 @@ public void test_ContinuousQueryAddListenerCodec_decodeRequest() { @Test public void test_ContinuousQueryAddListenerCodec_encodeResponse() { - int fileClientMessageIndex = 640; + int fileClientMessageIndex = 634; ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5684,7 +5638,7 @@ public void test_ContinuousQueryAddListenerCodec_encodeResponse() { @Test public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { - int fileClientMessageIndex = 641; + int fileClientMessageIndex = 635; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheSingleEvent(aQueryCacheEventData); compareClientMessages(fromFile, encoded); @@ -5692,7 +5646,7 @@ public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { @Test public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { - int fileClientMessageIndex = 642; + int fileClientMessageIndex = 636; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheBatchEvent(aListOfQueryCacheEventData, aString, anInt); compareClientMessages(fromFile, encoded); @@ -5700,7 +5654,7 @@ public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { @Test public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { - int fileClientMessageIndex = 643; + int fileClientMessageIndex = 637; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQuerySetReadCursorCodec.RequestParameters parameters = ContinuousQuerySetReadCursorCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5710,7 +5664,7 @@ public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { @Test public void test_ContinuousQuerySetReadCursorCodec_encodeResponse() { - int fileClientMessageIndex = 644; + int fileClientMessageIndex = 638; ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5718,7 +5672,7 @@ public void test_ContinuousQuerySetReadCursorCodec_encodeResponse() { @Test public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { - int fileClientMessageIndex = 645; + int fileClientMessageIndex = 639; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ContinuousQueryDestroyCacheCodec.RequestParameters parameters = ContinuousQueryDestroyCacheCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -5727,7 +5681,7 @@ public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { @Test public void test_ContinuousQueryDestroyCacheCodec_encodeResponse() { - int fileClientMessageIndex = 646; + int fileClientMessageIndex = 640; ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5735,14 +5689,14 @@ public void test_ContinuousQueryDestroyCacheCodec_encodeResponse() { @Test public void test_RingbufferSizeCodec_decodeRequest() { - int fileClientMessageIndex = 647; + int fileClientMessageIndex = 641; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferSizeCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferSizeCodec_encodeResponse() { - int fileClientMessageIndex = 648; + int fileClientMessageIndex = 642; ClientMessage encoded = RingbufferSizeCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5750,14 +5704,14 @@ public void test_RingbufferSizeCodec_encodeResponse() { @Test public void test_RingbufferTailSequenceCodec_decodeRequest() { - int fileClientMessageIndex = 649; + int fileClientMessageIndex = 643; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferTailSequenceCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferTailSequenceCodec_encodeResponse() { - int fileClientMessageIndex = 650; + int fileClientMessageIndex = 644; ClientMessage encoded = RingbufferTailSequenceCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5765,14 +5719,14 @@ public void test_RingbufferTailSequenceCodec_encodeResponse() { @Test public void test_RingbufferHeadSequenceCodec_decodeRequest() { - int fileClientMessageIndex = 651; + int fileClientMessageIndex = 645; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferHeadSequenceCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferHeadSequenceCodec_encodeResponse() { - int fileClientMessageIndex = 652; + int fileClientMessageIndex = 646; ClientMessage encoded = RingbufferHeadSequenceCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5780,14 +5734,14 @@ public void test_RingbufferHeadSequenceCodec_encodeResponse() { @Test public void test_RingbufferCapacityCodec_decodeRequest() { - int fileClientMessageIndex = 653; + int fileClientMessageIndex = 647; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferCapacityCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferCapacityCodec_encodeResponse() { - int fileClientMessageIndex = 654; + int fileClientMessageIndex = 648; ClientMessage encoded = RingbufferCapacityCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5795,14 +5749,14 @@ public void test_RingbufferCapacityCodec_encodeResponse() { @Test public void test_RingbufferRemainingCapacityCodec_decodeRequest() { - int fileClientMessageIndex = 655; + int fileClientMessageIndex = 649; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, RingbufferRemainingCapacityCodec.decodeRequest(fromFile))); } @Test public void test_RingbufferRemainingCapacityCodec_encodeResponse() { - int fileClientMessageIndex = 656; + int fileClientMessageIndex = 650; ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5810,7 +5764,7 @@ public void test_RingbufferRemainingCapacityCodec_encodeResponse() { @Test public void test_RingbufferAddCodec_decodeRequest() { - int fileClientMessageIndex = 657; + int fileClientMessageIndex = 651; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferAddCodec.RequestParameters parameters = RingbufferAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5820,7 +5774,7 @@ public void test_RingbufferAddCodec_decodeRequest() { @Test public void test_RingbufferAddCodec_encodeResponse() { - int fileClientMessageIndex = 658; + int fileClientMessageIndex = 652; ClientMessage encoded = RingbufferAddCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5828,7 +5782,7 @@ public void test_RingbufferAddCodec_encodeResponse() { @Test public void test_RingbufferReadOneCodec_decodeRequest() { - int fileClientMessageIndex = 659; + int fileClientMessageIndex = 653; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferReadOneCodec.RequestParameters parameters = RingbufferReadOneCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5837,7 +5791,7 @@ public void test_RingbufferReadOneCodec_decodeRequest() { @Test public void test_RingbufferReadOneCodec_encodeResponse() { - int fileClientMessageIndex = 660; + int fileClientMessageIndex = 654; ClientMessage encoded = RingbufferReadOneCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5845,7 +5799,7 @@ public void test_RingbufferReadOneCodec_encodeResponse() { @Test public void test_RingbufferAddAllCodec_decodeRequest() { - int fileClientMessageIndex = 661; + int fileClientMessageIndex = 655; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferAddAllCodec.RequestParameters parameters = RingbufferAddAllCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5855,7 +5809,7 @@ public void test_RingbufferAddAllCodec_decodeRequest() { @Test public void test_RingbufferAddAllCodec_encodeResponse() { - int fileClientMessageIndex = 662; + int fileClientMessageIndex = 656; ClientMessage encoded = RingbufferAddAllCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5863,7 +5817,7 @@ public void test_RingbufferAddAllCodec_encodeResponse() { @Test public void test_RingbufferReadManyCodec_decodeRequest() { - int fileClientMessageIndex = 663; + int fileClientMessageIndex = 657; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); RingbufferReadManyCodec.RequestParameters parameters = RingbufferReadManyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5875,7 +5829,7 @@ public void test_RingbufferReadManyCodec_decodeRequest() { @Test public void test_RingbufferReadManyCodec_encodeResponse() { - int fileClientMessageIndex = 664; + int fileClientMessageIndex = 658; ClientMessage encoded = RingbufferReadManyCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5883,14 +5837,14 @@ public void test_RingbufferReadManyCodec_encodeResponse() { @Test public void test_DurableExecutorShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 665; + int fileClientMessageIndex = 659; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, DurableExecutorShutdownCodec.decodeRequest(fromFile))); } @Test public void test_DurableExecutorShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 666; + int fileClientMessageIndex = 660; ClientMessage encoded = DurableExecutorShutdownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5898,14 +5852,14 @@ public void test_DurableExecutorShutdownCodec_encodeResponse() { @Test public void test_DurableExecutorIsShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 667; + int fileClientMessageIndex = 661; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, DurableExecutorIsShutdownCodec.decodeRequest(fromFile))); } @Test public void test_DurableExecutorIsShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 668; + int fileClientMessageIndex = 662; ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5913,7 +5867,7 @@ public void test_DurableExecutorIsShutdownCodec_encodeResponse() { @Test public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 669; + int fileClientMessageIndex = 663; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorSubmitToPartitionCodec.RequestParameters parameters = DurableExecutorSubmitToPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5922,7 +5876,7 @@ public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { @Test public void test_DurableExecutorSubmitToPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 670; + int fileClientMessageIndex = 664; ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5930,7 +5884,7 @@ public void test_DurableExecutorSubmitToPartitionCodec_encodeResponse() { @Test public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { - int fileClientMessageIndex = 671; + int fileClientMessageIndex = 665; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorRetrieveResultCodec.RequestParameters parameters = DurableExecutorRetrieveResultCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5939,7 +5893,7 @@ public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { @Test public void test_DurableExecutorRetrieveResultCodec_encodeResponse() { - int fileClientMessageIndex = 672; + int fileClientMessageIndex = 666; ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5947,7 +5901,7 @@ public void test_DurableExecutorRetrieveResultCodec_encodeResponse() { @Test public void test_DurableExecutorDisposeResultCodec_decodeRequest() { - int fileClientMessageIndex = 673; + int fileClientMessageIndex = 667; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorDisposeResultCodec.RequestParameters parameters = DurableExecutorDisposeResultCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5956,7 +5910,7 @@ public void test_DurableExecutorDisposeResultCodec_decodeRequest() { @Test public void test_DurableExecutorDisposeResultCodec_encodeResponse() { - int fileClientMessageIndex = 674; + int fileClientMessageIndex = 668; ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5964,7 +5918,7 @@ public void test_DurableExecutorDisposeResultCodec_encodeResponse() { @Test public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { - int fileClientMessageIndex = 675; + int fileClientMessageIndex = 669; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DurableExecutorRetrieveAndDisposeResultCodec.RequestParameters parameters = DurableExecutorRetrieveAndDisposeResultCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5973,7 +5927,7 @@ public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { @Test public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeResponse() { - int fileClientMessageIndex = 676; + int fileClientMessageIndex = 670; ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5981,7 +5935,7 @@ public void test_DurableExecutorRetrieveAndDisposeResultCodec_encodeResponse() { @Test public void test_CardinalityEstimatorAddCodec_decodeRequest() { - int fileClientMessageIndex = 677; + int fileClientMessageIndex = 671; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CardinalityEstimatorAddCodec.RequestParameters parameters = CardinalityEstimatorAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -5990,7 +5944,7 @@ public void test_CardinalityEstimatorAddCodec_decodeRequest() { @Test public void test_CardinalityEstimatorAddCodec_encodeResponse() { - int fileClientMessageIndex = 678; + int fileClientMessageIndex = 672; ClientMessage encoded = CardinalityEstimatorAddCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -5998,14 +5952,14 @@ public void test_CardinalityEstimatorAddCodec_encodeResponse() { @Test public void test_CardinalityEstimatorEstimateCodec_decodeRequest() { - int fileClientMessageIndex = 679; + int fileClientMessageIndex = 673; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CardinalityEstimatorEstimateCodec.decodeRequest(fromFile))); } @Test public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { - int fileClientMessageIndex = 680; + int fileClientMessageIndex = 674; ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6013,7 +5967,7 @@ public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { @Test public void test_ScheduledExecutorShutdownCodec_decodeRequest() { - int fileClientMessageIndex = 681; + int fileClientMessageIndex = 675; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorShutdownCodec.RequestParameters parameters = ScheduledExecutorShutdownCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6022,7 +5976,7 @@ public void test_ScheduledExecutorShutdownCodec_decodeRequest() { @Test public void test_ScheduledExecutorShutdownCodec_encodeResponse() { - int fileClientMessageIndex = 682; + int fileClientMessageIndex = 676; ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6030,7 +5984,7 @@ public void test_ScheduledExecutorShutdownCodec_encodeResponse() { @Test public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 683; + int fileClientMessageIndex = 677; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorSubmitToPartitionCodec.RequestParameters parameters = ScheduledExecutorSubmitToPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6045,7 +5999,7 @@ public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorSubmitToPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 684; + int fileClientMessageIndex = 678; ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6053,7 +6007,7 @@ public void test_ScheduledExecutorSubmitToPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { - int fileClientMessageIndex = 685; + int fileClientMessageIndex = 679; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorSubmitToMemberCodec.RequestParameters parameters = ScheduledExecutorSubmitToMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6069,7 +6023,7 @@ public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorSubmitToMemberCodec_encodeResponse() { - int fileClientMessageIndex = 686; + int fileClientMessageIndex = 680; ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6077,14 +6031,14 @@ public void test_ScheduledExecutorSubmitToMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeRequest() { - int fileClientMessageIndex = 687; + int fileClientMessageIndex = 681; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, ScheduledExecutorGetAllScheduledFuturesCodec.decodeRequest(fromFile))); } @Test public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { - int fileClientMessageIndex = 688; + int fileClientMessageIndex = 682; ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeResponse(aListOfScheduledTaskHandler); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6092,7 +6046,7 @@ public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 689; + int fileClientMessageIndex = 683; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetStatsFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6101,7 +6055,7 @@ public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 690; + int fileClientMessageIndex = 684; ClientMessage encoded = ScheduledExecutorGetStatsFromPartitionCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6109,7 +6063,7 @@ public void test_ScheduledExecutorGetStatsFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 691; + int fileClientMessageIndex = 685; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetStatsFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetStatsFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6119,7 +6073,7 @@ public void test_ScheduledExecutorGetStatsFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 692; + int fileClientMessageIndex = 686; ClientMessage encoded = ScheduledExecutorGetStatsFromMemberCodec.encodeResponse(aLong, aLong, aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6127,7 +6081,7 @@ public void test_ScheduledExecutorGetStatsFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 693; + int fileClientMessageIndex = 687; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetDelayFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6136,7 +6090,7 @@ public void test_ScheduledExecutorGetDelayFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 694; + int fileClientMessageIndex = 688; ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6144,7 +6098,7 @@ public void test_ScheduledExecutorGetDelayFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 695; + int fileClientMessageIndex = 689; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetDelayFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetDelayFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6154,7 +6108,7 @@ public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 696; + int fileClientMessageIndex = 690; ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6162,7 +6116,7 @@ public void test_ScheduledExecutorGetDelayFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 697; + int fileClientMessageIndex = 691; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorCancelFromPartitionCodec.RequestParameters parameters = ScheduledExecutorCancelFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6172,7 +6126,7 @@ public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorCancelFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 698; + int fileClientMessageIndex = 692; ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6180,7 +6134,7 @@ public void test_ScheduledExecutorCancelFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 699; + int fileClientMessageIndex = 693; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorCancelFromMemberCodec.RequestParameters parameters = ScheduledExecutorCancelFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6191,7 +6145,7 @@ public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorCancelFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 700; + int fileClientMessageIndex = 694; ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6199,7 +6153,7 @@ public void test_ScheduledExecutorCancelFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 701; + int fileClientMessageIndex = 695; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsCancelledFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6208,7 +6162,7 @@ public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() @Test public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 702; + int fileClientMessageIndex = 696; ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6216,7 +6170,7 @@ public void test_ScheduledExecutorIsCancelledFromPartitionCodec_encodeResponse() @Test public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 703; + int fileClientMessageIndex = 697; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsCancelledFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsCancelledFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6226,7 +6180,7 @@ public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 704; + int fileClientMessageIndex = 698; ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6234,7 +6188,7 @@ public void test_ScheduledExecutorIsCancelledFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 705; + int fileClientMessageIndex = 699; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsDoneFromPartitionCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6243,7 +6197,7 @@ public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 706; + int fileClientMessageIndex = 700; ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6251,7 +6205,7 @@ public void test_ScheduledExecutorIsDoneFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 707; + int fileClientMessageIndex = 701; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorIsDoneFromMemberCodec.RequestParameters parameters = ScheduledExecutorIsDoneFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6261,7 +6215,7 @@ public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 708; + int fileClientMessageIndex = 702; ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6269,7 +6223,7 @@ public void test_ScheduledExecutorIsDoneFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 709; + int fileClientMessageIndex = 703; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetResultFromPartitionCodec.RequestParameters parameters = ScheduledExecutorGetResultFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6278,7 +6232,7 @@ public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 710; + int fileClientMessageIndex = 704; ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6286,7 +6240,7 @@ public void test_ScheduledExecutorGetResultFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 711; + int fileClientMessageIndex = 705; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorGetResultFromMemberCodec.RequestParameters parameters = ScheduledExecutorGetResultFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6296,7 +6250,7 @@ public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorGetResultFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 712; + int fileClientMessageIndex = 706; ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeResponse(aData); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6304,7 +6258,7 @@ public void test_ScheduledExecutorGetResultFromMemberCodec_encodeResponse() { @Test public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { - int fileClientMessageIndex = 713; + int fileClientMessageIndex = 707; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorDisposeFromPartitionCodec.RequestParameters parameters = ScheduledExecutorDisposeFromPartitionCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6313,7 +6267,7 @@ public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { @Test public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeResponse() { - int fileClientMessageIndex = 714; + int fileClientMessageIndex = 708; ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6321,7 +6275,7 @@ public void test_ScheduledExecutorDisposeFromPartitionCodec_encodeResponse() { @Test public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { - int fileClientMessageIndex = 715; + int fileClientMessageIndex = 709; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ScheduledExecutorDisposeFromMemberCodec.RequestParameters parameters = ScheduledExecutorDisposeFromMemberCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.schedulerName)); @@ -6331,7 +6285,7 @@ public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { @Test public void test_ScheduledExecutorDisposeFromMemberCodec_encodeResponse() { - int fileClientMessageIndex = 716; + int fileClientMessageIndex = 710; ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6339,7 +6293,7 @@ public void test_ScheduledExecutorDisposeFromMemberCodec_encodeResponse() { @Test public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 717; + int fileClientMessageIndex = 711; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddMultiMapConfigCodec.RequestParameters parameters = DynamicConfigAddMultiMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6356,7 +6310,7 @@ public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddMultiMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 718; + int fileClientMessageIndex = 712; ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6364,7 +6318,7 @@ public void test_DynamicConfigAddMultiMapConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { - int fileClientMessageIndex = 719; + int fileClientMessageIndex = 713; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddRingbufferConfigCodec.RequestParameters parameters = DynamicConfigAddRingbufferConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6381,7 +6335,7 @@ public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddRingbufferConfigCodec_encodeResponse() { - int fileClientMessageIndex = 720; + int fileClientMessageIndex = 714; ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6389,7 +6343,7 @@ public void test_DynamicConfigAddRingbufferConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 721; + int fileClientMessageIndex = 715; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddCardinalityEstimatorConfigCodec.RequestParameters parameters = DynamicConfigAddCardinalityEstimatorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6402,7 +6356,7 @@ public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() @Test public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 722; + int fileClientMessageIndex = 716; ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6410,7 +6364,7 @@ public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_encodeResponse( @Test public void test_DynamicConfigAddListConfigCodec_decodeRequest() { - int fileClientMessageIndex = 723; + int fileClientMessageIndex = 717; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddListConfigCodec.RequestParameters parameters = DynamicConfigAddListConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6426,7 +6380,7 @@ public void test_DynamicConfigAddListConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddListConfigCodec_encodeResponse() { - int fileClientMessageIndex = 724; + int fileClientMessageIndex = 718; ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6434,7 +6388,7 @@ public void test_DynamicConfigAddListConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { - int fileClientMessageIndex = 725; + int fileClientMessageIndex = 719; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddSetConfigCodec.RequestParameters parameters = DynamicConfigAddSetConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6450,7 +6404,7 @@ public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddSetConfigCodec_encodeResponse() { - int fileClientMessageIndex = 726; + int fileClientMessageIndex = 720; ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6458,7 +6412,7 @@ public void test_DynamicConfigAddSetConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 727; + int fileClientMessageIndex = 721; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddReplicatedMapConfigCodec.RequestParameters parameters = DynamicConfigAddReplicatedMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6473,7 +6427,7 @@ public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 728; + int fileClientMessageIndex = 722; ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6481,7 +6435,7 @@ public void test_DynamicConfigAddReplicatedMapConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { - int fileClientMessageIndex = 729; + int fileClientMessageIndex = 723; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddTopicConfigCodec.RequestParameters parameters = DynamicConfigAddTopicConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6493,7 +6447,7 @@ public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddTopicConfigCodec_encodeResponse() { - int fileClientMessageIndex = 730; + int fileClientMessageIndex = 724; ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6501,7 +6455,7 @@ public void test_DynamicConfigAddTopicConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 731; + int fileClientMessageIndex = 725; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddExecutorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6513,7 +6467,7 @@ public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddExecutorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 732; + int fileClientMessageIndex = 726; ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6521,7 +6475,7 @@ public void test_DynamicConfigAddExecutorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 733; + int fileClientMessageIndex = 727; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddDurableExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddDurableExecutorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6535,7 +6489,7 @@ public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 734; + int fileClientMessageIndex = 728; ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6543,7 +6497,7 @@ public void test_DynamicConfigAddDurableExecutorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 735; + int fileClientMessageIndex = 729; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddScheduledExecutorConfigCodec.RequestParameters parameters = DynamicConfigAddScheduledExecutorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6559,7 +6513,7 @@ public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 736; + int fileClientMessageIndex = 730; ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6567,7 +6521,7 @@ public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { - int fileClientMessageIndex = 737; + int fileClientMessageIndex = 731; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddQueueConfigCodec.RequestParameters parameters = DynamicConfigAddQueueConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6587,7 +6541,7 @@ public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddQueueConfigCodec_encodeResponse() { - int fileClientMessageIndex = 738; + int fileClientMessageIndex = 732; ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6595,7 +6549,7 @@ public void test_DynamicConfigAddQueueConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 739; + int fileClientMessageIndex = 733; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddMapConfigCodec.RequestParameters parameters = DynamicConfigAddMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6629,7 +6583,7 @@ public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 740; + int fileClientMessageIndex = 734; ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6637,7 +6591,7 @@ public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { - int fileClientMessageIndex = 741; + int fileClientMessageIndex = 735; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddReliableTopicConfigCodec.RequestParameters parameters = DynamicConfigAddReliableTopicConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6650,7 +6604,7 @@ public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddReliableTopicConfigCodec_encodeResponse() { - int fileClientMessageIndex = 742; + int fileClientMessageIndex = 736; ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6658,7 +6612,7 @@ public void test_DynamicConfigAddReliableTopicConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { - int fileClientMessageIndex = 743; + int fileClientMessageIndex = 737; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddCacheConfigCodec.RequestParameters parameters = DynamicConfigAddCacheConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6691,7 +6645,7 @@ public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { - int fileClientMessageIndex = 744; + int fileClientMessageIndex = 738; ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6699,7 +6653,7 @@ public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { - int fileClientMessageIndex = 745; + int fileClientMessageIndex = 739; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddFlakeIdGeneratorConfigCodec.RequestParameters parameters = DynamicConfigAddFlakeIdGeneratorConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6715,7 +6669,7 @@ public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeResponse() { - int fileClientMessageIndex = 746; + int fileClientMessageIndex = 740; ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6723,7 +6677,7 @@ public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_encodeResponse() { @Test public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { - int fileClientMessageIndex = 747; + int fileClientMessageIndex = 741; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); DynamicConfigAddPNCounterConfigCodec.RequestParameters parameters = DynamicConfigAddPNCounterConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6734,7 +6688,7 @@ public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { @Test public void test_DynamicConfigAddPNCounterConfigCodec_encodeResponse() { - int fileClientMessageIndex = 748; + int fileClientMessageIndex = 742; ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6742,7 +6696,7 @@ public void test_DynamicConfigAddPNCounterConfigCodec_encodeResponse() { @Test public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { - int fileClientMessageIndex = 749; + int fileClientMessageIndex = 743; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); FlakeIdGeneratorNewIdBatchCodec.RequestParameters parameters = FlakeIdGeneratorNewIdBatchCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6751,7 +6705,7 @@ public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { @Test public void test_FlakeIdGeneratorNewIdBatchCodec_encodeResponse() { - int fileClientMessageIndex = 750; + int fileClientMessageIndex = 744; ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeResponse(aLong, aLong, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6759,7 +6713,7 @@ public void test_FlakeIdGeneratorNewIdBatchCodec_encodeResponse() { @Test public void test_PNCounterGetCodec_decodeRequest() { - int fileClientMessageIndex = 751; + int fileClientMessageIndex = 745; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); PNCounterGetCodec.RequestParameters parameters = PNCounterGetCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6769,7 +6723,7 @@ public void test_PNCounterGetCodec_decodeRequest() { @Test public void test_PNCounterGetCodec_encodeResponse() { - int fileClientMessageIndex = 752; + int fileClientMessageIndex = 746; ClientMessage encoded = PNCounterGetCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6777,7 +6731,7 @@ public void test_PNCounterGetCodec_encodeResponse() { @Test public void test_PNCounterAddCodec_decodeRequest() { - int fileClientMessageIndex = 753; + int fileClientMessageIndex = 747; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); PNCounterAddCodec.RequestParameters parameters = PNCounterAddCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -6789,7 +6743,7 @@ public void test_PNCounterAddCodec_decodeRequest() { @Test public void test_PNCounterAddCodec_encodeResponse() { - int fileClientMessageIndex = 754; + int fileClientMessageIndex = 748; ClientMessage encoded = PNCounterAddCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6797,14 +6751,14 @@ public void test_PNCounterAddCodec_encodeResponse() { @Test public void test_PNCounterGetConfiguredReplicaCountCodec_decodeRequest() { - int fileClientMessageIndex = 755; + int fileClientMessageIndex = 749; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, PNCounterGetConfiguredReplicaCountCodec.decodeRequest(fromFile))); } @Test public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { - int fileClientMessageIndex = 756; + int fileClientMessageIndex = 750; ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeResponse(anInt); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6812,14 +6766,14 @@ public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { @Test public void test_CPGroupCreateCPGroupCodec_decodeRequest() { - int fileClientMessageIndex = 757; + int fileClientMessageIndex = 751; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, CPGroupCreateCPGroupCodec.decodeRequest(fromFile))); } @Test public void test_CPGroupCreateCPGroupCodec_encodeResponse() { - int fileClientMessageIndex = 758; + int fileClientMessageIndex = 752; ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeResponse(aRaftGroupId); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6827,7 +6781,7 @@ public void test_CPGroupCreateCPGroupCodec_encodeResponse() { @Test public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { - int fileClientMessageIndex = 759; + int fileClientMessageIndex = 753; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPGroupDestroyCPObjectCodec.RequestParameters parameters = CPGroupDestroyCPObjectCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6837,7 +6791,7 @@ public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { @Test public void test_CPGroupDestroyCPObjectCodec_encodeResponse() { - int fileClientMessageIndex = 760; + int fileClientMessageIndex = 754; ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6845,7 +6799,7 @@ public void test_CPGroupDestroyCPObjectCodec_encodeResponse() { @Test public void test_CPSessionCreateSessionCodec_decodeRequest() { - int fileClientMessageIndex = 761; + int fileClientMessageIndex = 755; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPSessionCreateSessionCodec.RequestParameters parameters = CPSessionCreateSessionCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6854,7 +6808,7 @@ public void test_CPSessionCreateSessionCodec_decodeRequest() { @Test public void test_CPSessionCreateSessionCodec_encodeResponse() { - int fileClientMessageIndex = 762; + int fileClientMessageIndex = 756; ClientMessage encoded = CPSessionCreateSessionCodec.encodeResponse(aLong, aLong, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6862,7 +6816,7 @@ public void test_CPSessionCreateSessionCodec_encodeResponse() { @Test public void test_CPSessionCloseSessionCodec_decodeRequest() { - int fileClientMessageIndex = 763; + int fileClientMessageIndex = 757; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPSessionCloseSessionCodec.RequestParameters parameters = CPSessionCloseSessionCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6871,7 +6825,7 @@ public void test_CPSessionCloseSessionCodec_decodeRequest() { @Test public void test_CPSessionCloseSessionCodec_encodeResponse() { - int fileClientMessageIndex = 764; + int fileClientMessageIndex = 758; ClientMessage encoded = CPSessionCloseSessionCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6879,7 +6833,7 @@ public void test_CPSessionCloseSessionCodec_encodeResponse() { @Test public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { - int fileClientMessageIndex = 765; + int fileClientMessageIndex = 759; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); CPSessionHeartbeatSessionCodec.RequestParameters parameters = CPSessionHeartbeatSessionCodec.decodeRequest(fromFile); assertTrue(isEqual(aRaftGroupId, parameters.groupId)); @@ -6888,7 +6842,7 @@ public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { @Test public void test_CPSessionHeartbeatSessionCodec_encodeResponse() { - int fileClientMessageIndex = 766; + int fileClientMessageIndex = 760; ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6896,14 +6850,14 @@ public void test_CPSessionHeartbeatSessionCodec_encodeResponse() { @Test public void test_CPSessionGenerateThreadIdCodec_decodeRequest() { - int fileClientMessageIndex = 767; + int fileClientMessageIndex = 761; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aRaftGroupId, CPSessionGenerateThreadIdCodec.decodeRequest(fromFile))); } @Test public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { - int fileClientMessageIndex = 768; + int fileClientMessageIndex = 762; ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeResponse(aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6911,7 +6865,7 @@ public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { @Test public void test_MCReadMetricsCodec_decodeRequest() { - int fileClientMessageIndex = 769; + int fileClientMessageIndex = 763; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCReadMetricsCodec.RequestParameters parameters = MCReadMetricsCodec.decodeRequest(fromFile); assertTrue(isEqual(aUUID, parameters.uuid)); @@ -6920,7 +6874,7 @@ public void test_MCReadMetricsCodec_decodeRequest() { @Test public void test_MCReadMetricsCodec_encodeResponse() { - int fileClientMessageIndex = 770; + int fileClientMessageIndex = 764; ClientMessage encoded = MCReadMetricsCodec.encodeResponse(aListOfLongToByteArray, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6928,14 +6882,14 @@ public void test_MCReadMetricsCodec_encodeResponse() { @Test public void test_MCChangeClusterStateCodec_decodeRequest() { - int fileClientMessageIndex = 771; + int fileClientMessageIndex = 765; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anInt, MCChangeClusterStateCodec.decodeRequest(fromFile))); } @Test public void test_MCChangeClusterStateCodec_encodeResponse() { - int fileClientMessageIndex = 772; + int fileClientMessageIndex = 766; ClientMessage encoded = MCChangeClusterStateCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6943,14 +6897,14 @@ public void test_MCChangeClusterStateCodec_encodeResponse() { @Test public void test_MCGetMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 773; + int fileClientMessageIndex = 767; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MCGetMapConfigCodec.decodeRequest(fromFile))); } @Test public void test_MCGetMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 774; + int fileClientMessageIndex = 768; ClientMessage encoded = MCGetMapConfigCodec.encodeResponse(anInt, anInt, anInt, anInt, anInt, anInt, anInt, aBoolean, anInt, aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6958,7 +6912,7 @@ public void test_MCGetMapConfigCodec_encodeResponse() { @Test public void test_MCUpdateMapConfigCodec_decodeRequest() { - int fileClientMessageIndex = 775; + int fileClientMessageIndex = 769; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCUpdateMapConfigCodec.RequestParameters parameters = MCUpdateMapConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.mapName)); @@ -6972,7 +6926,7 @@ public void test_MCUpdateMapConfigCodec_decodeRequest() { @Test public void test_MCUpdateMapConfigCodec_encodeResponse() { - int fileClientMessageIndex = 776; + int fileClientMessageIndex = 770; ClientMessage encoded = MCUpdateMapConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6980,12 +6934,12 @@ public void test_MCUpdateMapConfigCodec_encodeResponse() { @Test public void test_MCGetMemberConfigCodec_decodeRequest() { - int fileClientMessageIndex = 777; + int fileClientMessageIndex = 771; } @Test public void test_MCGetMemberConfigCodec_encodeResponse() { - int fileClientMessageIndex = 778; + int fileClientMessageIndex = 772; ClientMessage encoded = MCGetMemberConfigCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -6993,12 +6947,12 @@ public void test_MCGetMemberConfigCodec_encodeResponse() { @Test public void test_MCRunGcCodec_decodeRequest() { - int fileClientMessageIndex = 779; + int fileClientMessageIndex = 773; } @Test public void test_MCRunGcCodec_encodeResponse() { - int fileClientMessageIndex = 780; + int fileClientMessageIndex = 774; ClientMessage encoded = MCRunGcCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7006,14 +6960,14 @@ public void test_MCRunGcCodec_encodeResponse() { @Test public void test_MCGetThreadDumpCodec_decodeRequest() { - int fileClientMessageIndex = 781; + int fileClientMessageIndex = 775; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, MCGetThreadDumpCodec.decodeRequest(fromFile))); } @Test public void test_MCGetThreadDumpCodec_encodeResponse() { - int fileClientMessageIndex = 782; + int fileClientMessageIndex = 776; ClientMessage encoded = MCGetThreadDumpCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7021,12 +6975,12 @@ public void test_MCGetThreadDumpCodec_encodeResponse() { @Test public void test_MCShutdownMemberCodec_decodeRequest() { - int fileClientMessageIndex = 783; + int fileClientMessageIndex = 777; } @Test public void test_MCShutdownMemberCodec_encodeResponse() { - int fileClientMessageIndex = 784; + int fileClientMessageIndex = 778; ClientMessage encoded = MCShutdownMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7034,12 +6988,12 @@ public void test_MCShutdownMemberCodec_encodeResponse() { @Test public void test_MCPromoteLiteMemberCodec_decodeRequest() { - int fileClientMessageIndex = 785; + int fileClientMessageIndex = 779; } @Test public void test_MCPromoteLiteMemberCodec_encodeResponse() { - int fileClientMessageIndex = 786; + int fileClientMessageIndex = 780; ClientMessage encoded = MCPromoteLiteMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7047,12 +7001,12 @@ public void test_MCPromoteLiteMemberCodec_encodeResponse() { @Test public void test_MCGetSystemPropertiesCodec_decodeRequest() { - int fileClientMessageIndex = 787; + int fileClientMessageIndex = 781; } @Test public void test_MCGetSystemPropertiesCodec_encodeResponse() { - int fileClientMessageIndex = 788; + int fileClientMessageIndex = 782; ClientMessage encoded = MCGetSystemPropertiesCodec.encodeResponse(aListOfStringToString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7060,12 +7014,12 @@ public void test_MCGetSystemPropertiesCodec_encodeResponse() { @Test public void test_MCGetTimedMemberStateCodec_decodeRequest() { - int fileClientMessageIndex = 789; + int fileClientMessageIndex = 783; } @Test public void test_MCGetTimedMemberStateCodec_encodeResponse() { - int fileClientMessageIndex = 790; + int fileClientMessageIndex = 784; ClientMessage encoded = MCGetTimedMemberStateCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7073,14 +7027,14 @@ public void test_MCGetTimedMemberStateCodec_encodeResponse() { @Test public void test_MCMatchMCConfigCodec_decodeRequest() { - int fileClientMessageIndex = 791; + int fileClientMessageIndex = 785; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aString, MCMatchMCConfigCodec.decodeRequest(fromFile))); } @Test public void test_MCMatchMCConfigCodec_encodeResponse() { - int fileClientMessageIndex = 792; + int fileClientMessageIndex = 786; ClientMessage encoded = MCMatchMCConfigCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7088,7 +7042,7 @@ public void test_MCMatchMCConfigCodec_encodeResponse() { @Test public void test_MCApplyMCConfigCodec_decodeRequest() { - int fileClientMessageIndex = 793; + int fileClientMessageIndex = 787; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCApplyMCConfigCodec.RequestParameters parameters = MCApplyMCConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.eTag)); @@ -7098,7 +7052,7 @@ public void test_MCApplyMCConfigCodec_decodeRequest() { @Test public void test_MCApplyMCConfigCodec_encodeResponse() { - int fileClientMessageIndex = 794; + int fileClientMessageIndex = 788; ClientMessage encoded = MCApplyMCConfigCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7106,12 +7060,12 @@ public void test_MCApplyMCConfigCodec_encodeResponse() { @Test public void test_MCGetClusterMetadataCodec_decodeRequest() { - int fileClientMessageIndex = 795; + int fileClientMessageIndex = 789; } @Test public void test_MCGetClusterMetadataCodec_encodeResponse() { - int fileClientMessageIndex = 796; + int fileClientMessageIndex = 790; ClientMessage encoded = MCGetClusterMetadataCodec.encodeResponse(aByte, aString, aString, aLong); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7119,12 +7073,12 @@ public void test_MCGetClusterMetadataCodec_encodeResponse() { @Test public void test_MCShutdownClusterCodec_decodeRequest() { - int fileClientMessageIndex = 797; + int fileClientMessageIndex = 791; } @Test public void test_MCShutdownClusterCodec_encodeResponse() { - int fileClientMessageIndex = 798; + int fileClientMessageIndex = 792; ClientMessage encoded = MCShutdownClusterCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7132,7 +7086,7 @@ public void test_MCShutdownClusterCodec_encodeResponse() { @Test public void test_MCChangeClusterVersionCodec_decodeRequest() { - int fileClientMessageIndex = 799; + int fileClientMessageIndex = 793; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCChangeClusterVersionCodec.RequestParameters parameters = MCChangeClusterVersionCodec.decodeRequest(fromFile); assertTrue(isEqual(aByte, parameters.majorVersion)); @@ -7141,7 +7095,7 @@ public void test_MCChangeClusterVersionCodec_decodeRequest() { @Test public void test_MCChangeClusterVersionCodec_encodeResponse() { - int fileClientMessageIndex = 800; + int fileClientMessageIndex = 794; ClientMessage encoded = MCChangeClusterVersionCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7149,7 +7103,7 @@ public void test_MCChangeClusterVersionCodec_encodeResponse() { @Test public void test_MCRunScriptCodec_decodeRequest() { - int fileClientMessageIndex = 801; + int fileClientMessageIndex = 795; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCRunScriptCodec.RequestParameters parameters = MCRunScriptCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.engine)); @@ -7158,7 +7112,7 @@ public void test_MCRunScriptCodec_decodeRequest() { @Test public void test_MCRunScriptCodec_encodeResponse() { - int fileClientMessageIndex = 802; + int fileClientMessageIndex = 796; ClientMessage encoded = MCRunScriptCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7166,7 +7120,7 @@ public void test_MCRunScriptCodec_encodeResponse() { @Test public void test_MCRunConsoleCommandCodec_decodeRequest() { - int fileClientMessageIndex = 803; + int fileClientMessageIndex = 797; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCRunConsoleCommandCodec.RequestParameters parameters = MCRunConsoleCommandCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.namespace)); @@ -7175,7 +7129,7 @@ public void test_MCRunConsoleCommandCodec_decodeRequest() { @Test public void test_MCRunConsoleCommandCodec_encodeResponse() { - int fileClientMessageIndex = 804; + int fileClientMessageIndex = 798; ClientMessage encoded = MCRunConsoleCommandCodec.encodeResponse(aString); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7183,7 +7137,7 @@ public void test_MCRunConsoleCommandCodec_encodeResponse() { @Test public void test_MCChangeWanReplicationStateCodec_decodeRequest() { - int fileClientMessageIndex = 805; + int fileClientMessageIndex = 799; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCChangeWanReplicationStateCodec.RequestParameters parameters = MCChangeWanReplicationStateCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7193,7 +7147,7 @@ public void test_MCChangeWanReplicationStateCodec_decodeRequest() { @Test public void test_MCChangeWanReplicationStateCodec_encodeResponse() { - int fileClientMessageIndex = 806; + int fileClientMessageIndex = 800; ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7201,7 +7155,7 @@ public void test_MCChangeWanReplicationStateCodec_encodeResponse() { @Test public void test_MCClearWanQueuesCodec_decodeRequest() { - int fileClientMessageIndex = 807; + int fileClientMessageIndex = 801; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCClearWanQueuesCodec.RequestParameters parameters = MCClearWanQueuesCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7210,7 +7164,7 @@ public void test_MCClearWanQueuesCodec_decodeRequest() { @Test public void test_MCClearWanQueuesCodec_encodeResponse() { - int fileClientMessageIndex = 808; + int fileClientMessageIndex = 802; ClientMessage encoded = MCClearWanQueuesCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7218,7 +7172,7 @@ public void test_MCClearWanQueuesCodec_encodeResponse() { @Test public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { - int fileClientMessageIndex = 809; + int fileClientMessageIndex = 803; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCAddWanBatchPublisherConfigCodec.RequestParameters parameters = MCAddWanBatchPublisherConfigCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.name)); @@ -7235,7 +7189,7 @@ public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { @Test public void test_MCAddWanBatchPublisherConfigCodec_encodeResponse() { - int fileClientMessageIndex = 810; + int fileClientMessageIndex = 804; ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeResponse(aListOfStrings, aListOfStrings); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7243,7 +7197,7 @@ public void test_MCAddWanBatchPublisherConfigCodec_encodeResponse() { @Test public void test_MCWanSyncMapCodec_decodeRequest() { - int fileClientMessageIndex = 811; + int fileClientMessageIndex = 805; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCWanSyncMapCodec.RequestParameters parameters = MCWanSyncMapCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7254,7 +7208,7 @@ public void test_MCWanSyncMapCodec_decodeRequest() { @Test public void test_MCWanSyncMapCodec_encodeResponse() { - int fileClientMessageIndex = 812; + int fileClientMessageIndex = 806; ClientMessage encoded = MCWanSyncMapCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7262,7 +7216,7 @@ public void test_MCWanSyncMapCodec_encodeResponse() { @Test public void test_MCCheckWanConsistencyCodec_decodeRequest() { - int fileClientMessageIndex = 813; + int fileClientMessageIndex = 807; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); MCCheckWanConsistencyCodec.RequestParameters parameters = MCCheckWanConsistencyCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.wanReplicationName)); @@ -7272,7 +7226,7 @@ public void test_MCCheckWanConsistencyCodec_decodeRequest() { @Test public void test_MCCheckWanConsistencyCodec_encodeResponse() { - int fileClientMessageIndex = 814; + int fileClientMessageIndex = 808; ClientMessage encoded = MCCheckWanConsistencyCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7280,12 +7234,12 @@ public void test_MCCheckWanConsistencyCodec_encodeResponse() { @Test public void test_MCPollMCEventsCodec_decodeRequest() { - int fileClientMessageIndex = 815; + int fileClientMessageIndex = 809; } @Test public void test_MCPollMCEventsCodec_encodeResponse() { - int fileClientMessageIndex = 816; + int fileClientMessageIndex = 810; ClientMessage encoded = MCPollMCEventsCodec.encodeResponse(aListOfMCEvents); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7293,12 +7247,12 @@ public void test_MCPollMCEventsCodec_encodeResponse() { @Test public void test_MCGetCPMembersCodec_decodeRequest() { - int fileClientMessageIndex = 817; + int fileClientMessageIndex = 811; } @Test public void test_MCGetCPMembersCodec_encodeResponse() { - int fileClientMessageIndex = 818; + int fileClientMessageIndex = 812; ClientMessage encoded = MCGetCPMembersCodec.encodeResponse(aListOfUUIDToUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7306,12 +7260,12 @@ public void test_MCGetCPMembersCodec_encodeResponse() { @Test public void test_MCPromoteToCPMemberCodec_decodeRequest() { - int fileClientMessageIndex = 819; + int fileClientMessageIndex = 813; } @Test public void test_MCPromoteToCPMemberCodec_encodeResponse() { - int fileClientMessageIndex = 820; + int fileClientMessageIndex = 814; ClientMessage encoded = MCPromoteToCPMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7319,14 +7273,14 @@ public void test_MCPromoteToCPMemberCodec_encodeResponse() { @Test public void test_MCRemoveCPMemberCodec_decodeRequest() { - int fileClientMessageIndex = 821; + int fileClientMessageIndex = 815; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, MCRemoveCPMemberCodec.decodeRequest(fromFile))); } @Test public void test_MCRemoveCPMemberCodec_encodeResponse() { - int fileClientMessageIndex = 822; + int fileClientMessageIndex = 816; ClientMessage encoded = MCRemoveCPMemberCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7334,12 +7288,12 @@ public void test_MCRemoveCPMemberCodec_encodeResponse() { @Test public void test_MCResetCPSubsystemCodec_decodeRequest() { - int fileClientMessageIndex = 823; + int fileClientMessageIndex = 817; } @Test public void test_MCResetCPSubsystemCodec_encodeResponse() { - int fileClientMessageIndex = 824; + int fileClientMessageIndex = 818; ClientMessage encoded = MCResetCPSubsystemCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7347,12 +7301,12 @@ public void test_MCResetCPSubsystemCodec_encodeResponse() { @Test public void test_MCTriggerPartialStartCodec_decodeRequest() { - int fileClientMessageIndex = 825; + int fileClientMessageIndex = 819; } @Test public void test_MCTriggerPartialStartCodec_encodeResponse() { - int fileClientMessageIndex = 826; + int fileClientMessageIndex = 820; ClientMessage encoded = MCTriggerPartialStartCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7360,12 +7314,12 @@ public void test_MCTriggerPartialStartCodec_encodeResponse() { @Test public void test_MCTriggerForceStartCodec_decodeRequest() { - int fileClientMessageIndex = 827; + int fileClientMessageIndex = 821; } @Test public void test_MCTriggerForceStartCodec_encodeResponse() { - int fileClientMessageIndex = 828; + int fileClientMessageIndex = 822; ClientMessage encoded = MCTriggerForceStartCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7373,12 +7327,12 @@ public void test_MCTriggerForceStartCodec_encodeResponse() { @Test public void test_MCTriggerHotRestartBackupCodec_decodeRequest() { - int fileClientMessageIndex = 829; + int fileClientMessageIndex = 823; } @Test public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { - int fileClientMessageIndex = 830; + int fileClientMessageIndex = 824; ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7386,12 +7340,12 @@ public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { @Test public void test_MCInterruptHotRestartBackupCodec_decodeRequest() { - int fileClientMessageIndex = 831; + int fileClientMessageIndex = 825; } @Test public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { - int fileClientMessageIndex = 832; + int fileClientMessageIndex = 826; ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7399,7 +7353,7 @@ public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { @Test public void test_SqlExecuteCodec_decodeRequest() { - int fileClientMessageIndex = 833; + int fileClientMessageIndex = 827; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SqlExecuteCodec.RequestParameters parameters = SqlExecuteCodec.decodeRequest(fromFile); assertTrue(isEqual(aString, parameters.sql)); @@ -7410,7 +7364,7 @@ public void test_SqlExecuteCodec_decodeRequest() { @Test public void test_SqlExecuteCodec_encodeResponse() { - int fileClientMessageIndex = 834; + int fileClientMessageIndex = 828; ClientMessage encoded = SqlExecuteCodec.encodeResponse(anSqlQueryId, aListOfSqlColumnMetadata, aListOfListOfData, aBoolean, aLong, anSqlError); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7418,7 +7372,7 @@ public void test_SqlExecuteCodec_encodeResponse() { @Test public void test_SqlFetchCodec_decodeRequest() { - int fileClientMessageIndex = 835; + int fileClientMessageIndex = 829; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); SqlFetchCodec.RequestParameters parameters = SqlFetchCodec.decodeRequest(fromFile); assertTrue(isEqual(anSqlQueryId, parameters.queryId)); @@ -7427,7 +7381,7 @@ public void test_SqlFetchCodec_decodeRequest() { @Test public void test_SqlFetchCodec_encodeResponse() { - int fileClientMessageIndex = 836; + int fileClientMessageIndex = 830; ClientMessage encoded = SqlFetchCodec.encodeResponse(aListOfListOfData, aBoolean, anSqlError); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7435,14 +7389,14 @@ public void test_SqlFetchCodec_encodeResponse() { @Test public void test_SqlCloseCodec_decodeRequest() { - int fileClientMessageIndex = 837; + int fileClientMessageIndex = 831; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(anSqlQueryId, SqlCloseCodec.decodeRequest(fromFile))); } @Test public void test_SqlCloseCodec_encodeResponse() { - int fileClientMessageIndex = 838; + int fileClientMessageIndex = 832; ClientMessage encoded = SqlCloseCodec.encodeResponse(); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7450,14 +7404,14 @@ public void test_SqlCloseCodec_encodeResponse() { @Test public void test_CPSubsystemAddMembershipListenerCodec_decodeRequest() { - int fileClientMessageIndex = 839; + int fileClientMessageIndex = 833; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, CPSubsystemAddMembershipListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { - int fileClientMessageIndex = 840; + int fileClientMessageIndex = 834; ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7465,7 +7419,7 @@ public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { @Test public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEvent() { - int fileClientMessageIndex = 841; + int fileClientMessageIndex = 835; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeMembershipEventEvent(aCpMember, aByte); compareClientMessages(fromFile, encoded); @@ -7473,14 +7427,14 @@ public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEven @Test public void test_CPSubsystemRemoveMembershipListenerCodec_decodeRequest() { - int fileClientMessageIndex = 842; + int fileClientMessageIndex = 836; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, CPSubsystemRemoveMembershipListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { - int fileClientMessageIndex = 843; + int fileClientMessageIndex = 837; ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7488,14 +7442,14 @@ public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { @Test public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeRequest() { - int fileClientMessageIndex = 844; + int fileClientMessageIndex = 838; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aBoolean, CPSubsystemAddGroupAvailabilityListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { - int fileClientMessageIndex = 845; + int fileClientMessageIndex = 839; ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeResponse(aUUID); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); @@ -7503,7 +7457,7 @@ public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { @Test public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailabilityEventEvent() { - int fileClientMessageIndex = 846; + int fileClientMessageIndex = 840; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeGroupAvailabilityEventEvent(aRaftGroupId, aListOfCpMembers, aListOfCpMembers); compareClientMessages(fromFile, encoded); @@ -7511,14 +7465,14 @@ public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailab @Test public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeRequest() { - int fileClientMessageIndex = 847; + int fileClientMessageIndex = 841; ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); assertTrue(isEqual(aUUID, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeRequest(fromFile))); } @Test public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeResponse() { - int fileClientMessageIndex = 848; + int fileClientMessageIndex = 842; ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeResponse(aBoolean); ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); compareClientMessages(fromFile, encoded); diff --git a/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_2.java b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_2.java new file mode 100644 index 0000000000000..877586cc980ab --- /dev/null +++ b/hazelcast/src/test/java/com/hazelcast/client/protocol/compatibility/MemberCompatibilityTest_2_2.java @@ -0,0 +1,7552 @@ +/* + * Copyright (c) 2008-2020, 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_2 { + private List clientMessages = new ArrayList<>(); + + @Before + public void setUp() throws IOException { + File file = new File(getClass().getResource("/2.2.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_MapPutCodec_decodeRequest() { + int fileClientMessageIndex = 43; + 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 = 44; + ClientMessage encoded = MapPutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetCodec_decodeRequest() { + int fileClientMessageIndex = 45; + 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 = 46; + ClientMessage encoded = MapGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 47; + 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 = 48; + ClientMessage encoded = MapRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 49; + 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 = 50; + ClientMessage encoded = MapReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 51; + 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 = 52; + ClientMessage encoded = MapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 53; + 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 = 54; + ClientMessage encoded = MapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 55; + 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 = 56; + ClientMessage encoded = MapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 57; + 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 = 58; + ClientMessage encoded = MapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 59; + 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 = 60; + ClientMessage encoded = MapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFlushCodec_decodeRequest() { + int fileClientMessageIndex = 61; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapFlushCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapFlushCodec_encodeResponse() { + int fileClientMessageIndex = 62; + ClientMessage encoded = MapFlushCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 63; + 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 = 64; + ClientMessage encoded = MapTryRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryPutCodec_decodeRequest() { + int fileClientMessageIndex = 65; + 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 = 66; + ClientMessage encoded = MapTryPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientCodec_decodeRequest() { + int fileClientMessageIndex = 67; + 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 = 68; + ClientMessage encoded = MapPutTransientCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 69; + 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 = 70; + ClientMessage encoded = MapPutIfAbsentCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetCodec_decodeRequest() { + int fileClientMessageIndex = 71; + 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 = 72; + ClientMessage encoded = MapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLockCodec_decodeRequest() { + int fileClientMessageIndex = 73; + 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 = 74; + ClientMessage encoded = MapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 75; + 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 = 76; + ClientMessage encoded = MapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 77; + 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 = 78; + ClientMessage encoded = MapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 79; + 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 = 80; + ClientMessage encoded = MapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 81; + 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 = 82; + ClientMessage encoded = MapAddInterceptorCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveInterceptorCodec_decodeRequest() { + int fileClientMessageIndex = 83; + 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 = 84; + ClientMessage encoded = MapRemoveInterceptorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 85; + 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 = 86; + ClientMessage encoded = MapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 87; + 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 = 88; + 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 = 89; + ClientMessage encoded = MapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 90; + 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 = 91; + 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 = 92; + ClientMessage encoded = MapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 93; + 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 = 94; + 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 = 95; + ClientMessage encoded = MapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 96; + 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 = 97; + 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 = 98; + ClientMessage encoded = MapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 99; + 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 = 100; + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddPartitionLostListenerCodec_encodeMapPartitionLostEvent() { + int fileClientMessageIndex = 101; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddPartitionLostListenerCodec.encodeMapPartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 102; + 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 = 103; + ClientMessage encoded = MapRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetEntryViewCodec_decodeRequest() { + int fileClientMessageIndex = 104; + 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 = 105; + ClientMessage encoded = MapGetEntryViewCodec.encodeResponse(aSimpleEntryView, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictCodec_decodeRequest() { + int fileClientMessageIndex = 106; + 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 = 107; + ClientMessage encoded = MapEvictCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEvictAllCodec_decodeRequest() { + int fileClientMessageIndex = 108; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEvictAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEvictAllCodec_encodeResponse() { + int fileClientMessageIndex = 109; + ClientMessage encoded = MapEvictAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 110; + 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 = 111; + ClientMessage encoded = MapLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapLoadGivenKeysCodec_decodeRequest() { + int fileClientMessageIndex = 112; + 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 = 113; + ClientMessage encoded = MapLoadGivenKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 114; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 115; + ClientMessage encoded = MapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 116; + 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 = 117; + ClientMessage encoded = MapGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 118; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 119; + ClientMessage encoded = MapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 120; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 121; + ClientMessage encoded = MapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 122; + 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 = 123; + ClientMessage encoded = MapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 124; + 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 = 125; + ClientMessage encoded = MapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 126; + 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 = 127; + ClientMessage encoded = MapEntriesWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddIndexCodec_decodeRequest() { + int fileClientMessageIndex = 128; + 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 = 129; + ClientMessage encoded = MapAddIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 130; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 131; + ClientMessage encoded = MapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 132; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 133; + ClientMessage encoded = MapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 134; + 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 = 135; + ClientMessage encoded = MapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapClearCodec_decodeRequest() { + int fileClientMessageIndex = 136; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapClearCodec_encodeResponse() { + int fileClientMessageIndex = 137; + ClientMessage encoded = MapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeyCodec_decodeRequest() { + int fileClientMessageIndex = 138; + 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 = 139; + ClientMessage encoded = MapExecuteOnKeyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSubmitToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 140; + 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 = 141; + ClientMessage encoded = MapSubmitToKeyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 142; + 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 = 143; + ClientMessage encoded = MapExecuteOnAllKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 144; + 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 = 145; + ClientMessage encoded = MapExecuteWithPredicateCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapExecuteOnKeysCodec_decodeRequest() { + int fileClientMessageIndex = 146; + 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 = 147; + ClientMessage encoded = MapExecuteOnKeysCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 148; + 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 = 149; + ClientMessage encoded = MapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapKeySetWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 150; + 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 = 151; + ClientMessage encoded = MapKeySetWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapValuesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 152; + 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 = 153; + ClientMessage encoded = MapValuesWithPagingPredicateCodec.encodeResponse(aListOfData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEntriesWithPagingPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 154; + 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 = 155; + ClientMessage encoded = MapEntriesWithPagingPredicateCodec.encodeResponse(aListOfDataToData, anAnchorDataListHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchKeysCodec_decodeRequest() { + int fileClientMessageIndex = 156; + 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 = 157; + ClientMessage encoded = MapFetchKeysCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 158; + 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 = 159; + ClientMessage encoded = MapFetchEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateCodec_decodeRequest() { + int fileClientMessageIndex = 160; + 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 = 161; + ClientMessage encoded = MapAggregateCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAggregateWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 162; + 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 = 163; + ClientMessage encoded = MapAggregateWithPredicateCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectCodec_decodeRequest() { + int fileClientMessageIndex = 164; + 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 = 165; + ClientMessage encoded = MapProjectCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapProjectWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 166; + 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 = 167; + ClientMessage encoded = MapProjectWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchNearCacheInvalidationMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 168; + 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 = 169; + ClientMessage encoded = MapFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 170; + 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 = 171; + ClientMessage encoded = MapRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 172; + 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 = 173; + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapInvalidationEvent() { + int fileClientMessageIndex = 174; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapInvalidationEvent(aData, aUUID, aUUID, aLong); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapAddNearCacheInvalidationListenerCodec_encodeIMapBatchInvalidationEvent() { + int fileClientMessageIndex = 175; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = MapAddNearCacheInvalidationListenerCodec.encodeIMapBatchInvalidationEvent(aListOfData, aListOfUUIDs, aListOfUUIDs, aListOfLongs); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapFetchWithQueryCodec_decodeRequest() { + int fileClientMessageIndex = 176; + 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 = 177; + ClientMessage encoded = MapFetchWithQueryCodec.encodeResponse(aListOfData, aListOfIntegerToInteger); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 178; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MapEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MapEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 179; + ClientMessage encoded = MapEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 180; + 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 = 181; + ClientMessage encoded = MapEventJournalReadCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetTtlCodec_decodeRequest() { + int fileClientMessageIndex = 182; + 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 = 183; + ClientMessage encoded = MapSetTtlCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 184; + 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 = 185; + ClientMessage encoded = MapPutWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutTransientWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 186; + 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 = 187; + ClientMessage encoded = MapPutTransientWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapPutIfAbsentWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 188; + 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 = 189; + ClientMessage encoded = MapPutIfAbsentWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MapSetWithMaxIdleCodec_decodeRequest() { + int fileClientMessageIndex = 190; + 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 = 191; + ClientMessage encoded = MapSetWithMaxIdleCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 192; + 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 = 193; + ClientMessage encoded = MultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 194; + 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 = 195; + ClientMessage encoded = MultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 196; + 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 = 197; + ClientMessage encoded = MultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 198; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 199; + ClientMessage encoded = MultiMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 200; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 201; + ClientMessage encoded = MultiMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 202; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 203; + ClientMessage encoded = MultiMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 204; + 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 = 205; + ClientMessage encoded = MultiMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 206; + 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 = 207; + ClientMessage encoded = MultiMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapContainsEntryCodec_decodeRequest() { + int fileClientMessageIndex = 208; + 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 = 209; + ClientMessage encoded = MultiMapContainsEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 210; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 211; + ClientMessage encoded = MultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 212; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MultiMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MultiMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 213; + ClientMessage encoded = MultiMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 214; + 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 = 215; + ClientMessage encoded = MultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_decodeRequest() { + int fileClientMessageIndex = 216; + 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 = 217; + ClientMessage encoded = MultiMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 218; + 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 = 219; + 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 = 220; + ClientMessage encoded = MultiMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 221; + 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 = 222; + 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 = 223; + ClientMessage encoded = MultiMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapLockCodec_decodeRequest() { + int fileClientMessageIndex = 224; + 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 = 225; + ClientMessage encoded = MultiMapLockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 226; + 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 = 227; + ClientMessage encoded = MultiMapTryLockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapIsLockedCodec_decodeRequest() { + int fileClientMessageIndex = 228; + 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 = 229; + ClientMessage encoded = MultiMapIsLockedCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 230; + 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 = 231; + ClientMessage encoded = MultiMapUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapForceUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 232; + 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 = 233; + ClientMessage encoded = MultiMapForceUnlockCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 234; + 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 = 235; + ClientMessage encoded = MultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 236; + 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 = 237; + ClientMessage encoded = MultiMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MultiMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 238; + 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 = 239; + ClientMessage encoded = MultiMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 240; + 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 = 241; + ClientMessage encoded = QueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePutCodec_decodeRequest() { + int fileClientMessageIndex = 242; + 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 = 243; + ClientMessage encoded = QueuePutCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 244; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueSizeCodec_encodeResponse() { + int fileClientMessageIndex = 245; + ClientMessage encoded = QueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 246; + 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 = 247; + ClientMessage encoded = QueueRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 248; + 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 = 249; + ClientMessage encoded = QueuePollCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 250; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueTakeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueTakeCodec_encodeResponse() { + int fileClientMessageIndex = 251; + ClientMessage encoded = QueueTakeCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 252; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueuePeekCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueuePeekCodec_encodeResponse() { + int fileClientMessageIndex = 253; + ClientMessage encoded = QueuePeekCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 254; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 255; + ClientMessage encoded = QueueIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToCodec_decodeRequest() { + int fileClientMessageIndex = 256; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueDrainToCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueDrainToCodec_encodeResponse() { + int fileClientMessageIndex = 257; + ClientMessage encoded = QueueDrainToCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueDrainToMaxSizeCodec_decodeRequest() { + int fileClientMessageIndex = 258; + 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 = 259; + ClientMessage encoded = QueueDrainToMaxSizeCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsCodec_decodeRequest() { + int fileClientMessageIndex = 260; + 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 = 261; + ClientMessage encoded = QueueContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 262; + 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 = 263; + ClientMessage encoded = QueueContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 264; + 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 = 265; + ClientMessage encoded = QueueCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 266; + 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 = 267; + ClientMessage encoded = QueueCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueClearCodec_decodeRequest() { + int fileClientMessageIndex = 268; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueClearCodec_encodeResponse() { + int fileClientMessageIndex = 269; + ClientMessage encoded = QueueClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 270; + 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 = 271; + ClientMessage encoded = QueueAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 272; + 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 = 273; + ClientMessage encoded = QueueAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 274; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = QueueAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 275; + 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 = 276; + ClientMessage encoded = QueueRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 277; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 278; + ClientMessage encoded = QueueRemainingCapacityCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_QueueIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 279; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, QueueIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_QueueIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 280; + ClientMessage encoded = QueueIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishCodec_decodeRequest() { + int fileClientMessageIndex = 281; + 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 = 282; + ClientMessage encoded = TopicPublishCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 283; + 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 = 284; + ClientMessage encoded = TopicAddMessageListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicAddMessageListenerCodec_encodeTopicEvent() { + int fileClientMessageIndex = 285; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = TopicAddMessageListenerCodec.encodeTopicEvent(aData, aLong, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicRemoveMessageListenerCodec_decodeRequest() { + int fileClientMessageIndex = 286; + 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 = 287; + ClientMessage encoded = TopicRemoveMessageListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TopicPublishAllCodec_decodeRequest() { + int fileClientMessageIndex = 288; + 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 = 289; + ClientMessage encoded = TopicPublishAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 290; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListSizeCodec_encodeResponse() { + int fileClientMessageIndex = 291; + ClientMessage encoded = ListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsCodec_decodeRequest() { + int fileClientMessageIndex = 292; + 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 = 293; + ClientMessage encoded = ListContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 294; + 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 = 295; + ClientMessage encoded = ListContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddCodec_decodeRequest() { + int fileClientMessageIndex = 296; + 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 = 297; + ClientMessage encoded = ListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 298; + 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 = 299; + ClientMessage encoded = ListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 300; + 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 = 301; + ClientMessage encoded = ListAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 302; + 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 = 303; + ClientMessage encoded = ListCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 304; + 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 = 305; + ClientMessage encoded = ListCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListClearCodec_decodeRequest() { + int fileClientMessageIndex = 306; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListClearCodec_encodeResponse() { + int fileClientMessageIndex = 307; + ClientMessage encoded = ListClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 308; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 309; + ClientMessage encoded = ListGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 310; + 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 = 311; + ClientMessage encoded = ListAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 312; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ListAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 313; + 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 = 314; + ClientMessage encoded = ListRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 315; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 316; + ClientMessage encoded = ListIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddAllWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 317; + 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 = 318; + ClientMessage encoded = ListAddAllWithIndexCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListGetCodec_decodeRequest() { + int fileClientMessageIndex = 319; + 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 = 320; + ClientMessage encoded = ListGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSetCodec_decodeRequest() { + int fileClientMessageIndex = 321; + 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 = 322; + ClientMessage encoded = ListSetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListAddWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 323; + 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 = 324; + ClientMessage encoded = ListAddWithIndexCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListRemoveWithIndexCodec_decodeRequest() { + int fileClientMessageIndex = 325; + 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 = 326; + ClientMessage encoded = ListRemoveWithIndexCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListLastIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 327; + 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 = 328; + ClientMessage encoded = ListLastIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIndexOfCodec_decodeRequest() { + int fileClientMessageIndex = 329; + 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 = 330; + ClientMessage encoded = ListIndexOfCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListSubCodec_decodeRequest() { + int fileClientMessageIndex = 331; + 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 = 332; + ClientMessage encoded = ListSubCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 333; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ListIteratorCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ListIteratorCodec_encodeResponse() { + int fileClientMessageIndex = 334; + ClientMessage encoded = ListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ListListIteratorCodec_decodeRequest() { + int fileClientMessageIndex = 335; + 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 = 336; + ClientMessage encoded = ListListIteratorCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 337; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetSizeCodec_encodeResponse() { + int fileClientMessageIndex = 338; + ClientMessage encoded = SetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsCodec_decodeRequest() { + int fileClientMessageIndex = 339; + 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 = 340; + ClientMessage encoded = SetContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetContainsAllCodec_decodeRequest() { + int fileClientMessageIndex = 341; + 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 = 342; + ClientMessage encoded = SetContainsAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddCodec_decodeRequest() { + int fileClientMessageIndex = 343; + 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 = 344; + ClientMessage encoded = SetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 345; + 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 = 346; + ClientMessage encoded = SetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 347; + 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 = 348; + ClientMessage encoded = SetAddAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 349; + 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 = 350; + ClientMessage encoded = SetCompareAndRemoveAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetCompareAndRetainAllCodec_decodeRequest() { + int fileClientMessageIndex = 351; + 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 = 352; + ClientMessage encoded = SetCompareAndRetainAllCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetClearCodec_decodeRequest() { + int fileClientMessageIndex = 353; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetClearCodec_encodeResponse() { + int fileClientMessageIndex = 354; + ClientMessage encoded = SetClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 355; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetGetAllCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetGetAllCodec_encodeResponse() { + int fileClientMessageIndex = 356; + ClientMessage encoded = SetGetAllCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 357; + 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 = 358; + ClientMessage encoded = SetAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetAddListenerCodec_encodeItemEvent() { + int fileClientMessageIndex = 359; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = SetAddListenerCodec.encodeItemEvent(aData, aUUID, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetRemoveListenerCodec_decodeRequest() { + int fileClientMessageIndex = 360; + 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 = 361; + ClientMessage encoded = SetRemoveListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SetIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 362; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SetIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SetIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 363; + ClientMessage encoded = SetIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockLockCodec_decodeRequest() { + int fileClientMessageIndex = 364; + 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 = 365; + ClientMessage encoded = FencedLockLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockTryLockCodec_decodeRequest() { + int fileClientMessageIndex = 366; + 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 = 367; + ClientMessage encoded = FencedLockTryLockCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockUnlockCodec_decodeRequest() { + int fileClientMessageIndex = 368; + 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 = 369; + ClientMessage encoded = FencedLockUnlockCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FencedLockGetLockOwnershipCodec_decodeRequest() { + int fileClientMessageIndex = 370; + 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 = 371; + ClientMessage encoded = FencedLockGetLockOwnershipCodec.encodeResponse(aLong, anInt, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 372; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 373; + ClientMessage encoded = ExecutorServiceShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 374; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ExecutorServiceIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ExecutorServiceIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 375; + ClientMessage encoded = ExecutorServiceIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 376; + 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 = 377; + ClientMessage encoded = ExecutorServiceCancelOnPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceCancelOnMemberCodec_decodeRequest() { + int fileClientMessageIndex = 378; + 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 = 379; + ClientMessage encoded = ExecutorServiceCancelOnMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 380; + 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 = 381; + ClientMessage encoded = ExecutorServiceSubmitToPartitionCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ExecutorServiceSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 382; + 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 = 383; + ClientMessage encoded = ExecutorServiceSubmitToMemberCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongApplyCodec_decodeRequest() { + int fileClientMessageIndex = 384; + 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 = 385; + ClientMessage encoded = AtomicLongApplyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAlterCodec_decodeRequest() { + int fileClientMessageIndex = 386; + 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 = 387; + ClientMessage encoded = AtomicLongAlterCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongAddAndGetCodec_decodeRequest() { + int fileClientMessageIndex = 388; + 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 = 389; + ClientMessage encoded = AtomicLongAddAndGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 390; + 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 = 391; + ClientMessage encoded = AtomicLongCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetCodec_decodeRequest() { + int fileClientMessageIndex = 392; + 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 = 393; + ClientMessage encoded = AtomicLongGetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndAddCodec_decodeRequest() { + int fileClientMessageIndex = 394; + 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 = 395; + ClientMessage encoded = AtomicLongGetAndAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicLongGetAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 396; + 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 = 397; + ClientMessage encoded = AtomicLongGetAndSetCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefApplyCodec_decodeRequest() { + int fileClientMessageIndex = 398; + 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 = 399; + ClientMessage encoded = AtomicRefApplyCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefCompareAndSetCodec_decodeRequest() { + int fileClientMessageIndex = 400; + 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 = 401; + ClientMessage encoded = AtomicRefCompareAndSetCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefContainsCodec_decodeRequest() { + int fileClientMessageIndex = 402; + 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 = 403; + ClientMessage encoded = AtomicRefContainsCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefGetCodec_decodeRequest() { + int fileClientMessageIndex = 404; + 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 = 405; + ClientMessage encoded = AtomicRefGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_AtomicRefSetCodec_decodeRequest() { + int fileClientMessageIndex = 406; + 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 = 407; + ClientMessage encoded = AtomicRefSetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchTrySetCountCodec_decodeRequest() { + int fileClientMessageIndex = 408; + 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 = 409; + ClientMessage encoded = CountDownLatchTrySetCountCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchAwaitCodec_decodeRequest() { + int fileClientMessageIndex = 410; + 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 = 411; + ClientMessage encoded = CountDownLatchAwaitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchCountDownCodec_decodeRequest() { + int fileClientMessageIndex = 412; + 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 = 413; + ClientMessage encoded = CountDownLatchCountDownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetCountCodec_decodeRequest() { + int fileClientMessageIndex = 414; + 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 = 415; + ClientMessage encoded = CountDownLatchGetCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CountDownLatchGetRoundCodec_decodeRequest() { + int fileClientMessageIndex = 416; + 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 = 417; + ClientMessage encoded = CountDownLatchGetRoundCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreInitCodec_decodeRequest() { + int fileClientMessageIndex = 418; + 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 = 419; + ClientMessage encoded = SemaphoreInitCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAcquireCodec_decodeRequest() { + int fileClientMessageIndex = 420; + 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 = 421; + ClientMessage encoded = SemaphoreAcquireCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreReleaseCodec_decodeRequest() { + int fileClientMessageIndex = 422; + 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 = 423; + ClientMessage encoded = SemaphoreReleaseCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreDrainCodec_decodeRequest() { + int fileClientMessageIndex = 424; + 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 = 425; + ClientMessage encoded = SemaphoreDrainCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreChangeCodec_decodeRequest() { + int fileClientMessageIndex = 426; + 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 = 427; + ClientMessage encoded = SemaphoreChangeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreAvailablePermitsCodec_decodeRequest() { + int fileClientMessageIndex = 428; + 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 = 429; + ClientMessage encoded = SemaphoreAvailablePermitsCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_decodeRequest() { + int fileClientMessageIndex = 430; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, SemaphoreGetSemaphoreTypeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SemaphoreGetSemaphoreTypeCodec_encodeResponse() { + int fileClientMessageIndex = 431; + ClientMessage encoded = SemaphoreGetSemaphoreTypeCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 432; + 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 = 433; + ClientMessage encoded = ReplicatedMapPutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 434; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapSizeCodec_encodeResponse() { + int fileClientMessageIndex = 435; + ClientMessage encoded = ReplicatedMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 436; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapIsEmptyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapIsEmptyCodec_encodeResponse() { + int fileClientMessageIndex = 437; + ClientMessage encoded = ReplicatedMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 438; + 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 = 439; + ClientMessage encoded = ReplicatedMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 440; + 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 = 441; + ClientMessage encoded = ReplicatedMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 442; + 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 = 443; + ClientMessage encoded = ReplicatedMapGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 444; + 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 = 445; + ClientMessage encoded = ReplicatedMapRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapPutAllCodec_decodeRequest() { + int fileClientMessageIndex = 446; + 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 = 447; + ClientMessage encoded = ReplicatedMapPutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapClearCodec_decodeRequest() { + int fileClientMessageIndex = 448; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapClearCodec_encodeResponse() { + int fileClientMessageIndex = 449; + ClientMessage encoded = ReplicatedMapClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 450; + 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 = 451; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 452; + 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 = 453; + 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 = 454; + ClientMessage encoded = ReplicatedMapAddEntryListenerWithPredicateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerWithPredicateCodec_encodeEntryEvent() { + int fileClientMessageIndex = 455; + 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 = 456; + 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 = 457; + ClientMessage encoded = ReplicatedMapAddEntryListenerToKeyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerToKeyCodec_encodeEntryEvent() { + int fileClientMessageIndex = 458; + 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 = 459; + 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 = 460; + ClientMessage encoded = ReplicatedMapAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 461; + 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 = 462; + 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 = 463; + ClientMessage encoded = ReplicatedMapRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 464; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapKeySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapKeySetCodec_encodeResponse() { + int fileClientMessageIndex = 465; + ClientMessage encoded = ReplicatedMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 466; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapValuesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapValuesCodec_encodeResponse() { + int fileClientMessageIndex = 467; + ClientMessage encoded = ReplicatedMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_decodeRequest() { + int fileClientMessageIndex = 468; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ReplicatedMapEntrySetCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ReplicatedMapEntrySetCodec_encodeResponse() { + int fileClientMessageIndex = 469; + ClientMessage encoded = ReplicatedMapEntrySetCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 470; + 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 = 471; + ClientMessage encoded = ReplicatedMapAddNearCacheEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ReplicatedMapAddNearCacheEntryListenerCodec_encodeEntryEvent() { + int fileClientMessageIndex = 472; + 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 = 473; + 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 = 474; + ClientMessage encoded = TransactionalMapContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 475; + 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 = 476; + ClientMessage encoded = TransactionalMapGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapGetForUpdateCodec_decodeRequest() { + int fileClientMessageIndex = 477; + 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 = 478; + ClientMessage encoded = TransactionalMapGetForUpdateCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 479; + 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 = 480; + ClientMessage encoded = TransactionalMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapIsEmptyCodec_decodeRequest() { + int fileClientMessageIndex = 481; + 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 = 482; + ClientMessage encoded = TransactionalMapIsEmptyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 483; + 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 = 484; + ClientMessage encoded = TransactionalMapPutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapSetCodec_decodeRequest() { + int fileClientMessageIndex = 485; + 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 = 486; + ClientMessage encoded = TransactionalMapSetCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapPutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 487; + 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 = 488; + ClientMessage encoded = TransactionalMapPutIfAbsentCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 489; + 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 = 490; + ClientMessage encoded = TransactionalMapReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapReplaceIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 491; + 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 = 492; + ClientMessage encoded = TransactionalMapReplaceIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 493; + 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 = 494; + ClientMessage encoded = TransactionalMapRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapDeleteCodec_decodeRequest() { + int fileClientMessageIndex = 495; + 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 = 496; + ClientMessage encoded = TransactionalMapDeleteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapRemoveIfSameCodec_decodeRequest() { + int fileClientMessageIndex = 497; + 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 = 498; + ClientMessage encoded = TransactionalMapRemoveIfSameCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetCodec_decodeRequest() { + int fileClientMessageIndex = 499; + 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 = 500; + ClientMessage encoded = TransactionalMapKeySetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapKeySetWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 501; + 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 = 502; + ClientMessage encoded = TransactionalMapKeySetWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesCodec_decodeRequest() { + int fileClientMessageIndex = 503; + 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 = 504; + ClientMessage encoded = TransactionalMapValuesCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapValuesWithPredicateCodec_decodeRequest() { + int fileClientMessageIndex = 505; + 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 = 506; + ClientMessage encoded = TransactionalMapValuesWithPredicateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMapContainsValueCodec_decodeRequest() { + int fileClientMessageIndex = 507; + 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 = 508; + ClientMessage encoded = TransactionalMapContainsValueCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapPutCodec_decodeRequest() { + int fileClientMessageIndex = 509; + 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 = 510; + ClientMessage encoded = TransactionalMultiMapPutCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapGetCodec_decodeRequest() { + int fileClientMessageIndex = 511; + 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 = 512; + ClientMessage encoded = TransactionalMultiMapGetCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 513; + 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 = 514; + ClientMessage encoded = TransactionalMultiMapRemoveCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapRemoveEntryCodec_decodeRequest() { + int fileClientMessageIndex = 515; + 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 = 516; + ClientMessage encoded = TransactionalMultiMapRemoveEntryCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapValueCountCodec_decodeRequest() { + int fileClientMessageIndex = 517; + 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 = 518; + ClientMessage encoded = TransactionalMultiMapValueCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalMultiMapSizeCodec_decodeRequest() { + int fileClientMessageIndex = 519; + 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 = 520; + ClientMessage encoded = TransactionalMultiMapSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetAddCodec_decodeRequest() { + int fileClientMessageIndex = 521; + 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 = 522; + ClientMessage encoded = TransactionalSetAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 523; + 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 = 524; + ClientMessage encoded = TransactionalSetRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalSetSizeCodec_decodeRequest() { + int fileClientMessageIndex = 525; + 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 = 526; + ClientMessage encoded = TransactionalSetSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListAddCodec_decodeRequest() { + int fileClientMessageIndex = 527; + 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 = 528; + ClientMessage encoded = TransactionalListAddCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 529; + 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 = 530; + ClientMessage encoded = TransactionalListRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalListSizeCodec_decodeRequest() { + int fileClientMessageIndex = 531; + 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 = 532; + ClientMessage encoded = TransactionalListSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueOfferCodec_decodeRequest() { + int fileClientMessageIndex = 533; + 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 = 534; + ClientMessage encoded = TransactionalQueueOfferCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueTakeCodec_decodeRequest() { + int fileClientMessageIndex = 535; + 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 = 536; + ClientMessage encoded = TransactionalQueueTakeCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePollCodec_decodeRequest() { + int fileClientMessageIndex = 537; + 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 = 538; + ClientMessage encoded = TransactionalQueuePollCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueuePeekCodec_decodeRequest() { + int fileClientMessageIndex = 539; + 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 = 540; + ClientMessage encoded = TransactionalQueuePeekCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionalQueueSizeCodec_decodeRequest() { + int fileClientMessageIndex = 541; + 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 = 542; + ClientMessage encoded = TransactionalQueueSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 543; + 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 = 544; + ClientMessage encoded = CacheAddEntryListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddEntryListenerCodec_encodeCacheEvent() { + int fileClientMessageIndex = 545; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddEntryListenerCodec.encodeCacheEvent(anInt, aListOfCacheEventData, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheClearCodec_decodeRequest() { + int fileClientMessageIndex = 546; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheClearCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheClearCodec_encodeResponse() { + int fileClientMessageIndex = 547; + ClientMessage encoded = CacheClearCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllKeysCodec_decodeRequest() { + int fileClientMessageIndex = 548; + 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 = 549; + ClientMessage encoded = CacheRemoveAllKeysCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveAllCodec_decodeRequest() { + int fileClientMessageIndex = 550; + 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 = 551; + ClientMessage encoded = CacheRemoveAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheContainsKeyCodec_decodeRequest() { + int fileClientMessageIndex = 552; + 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 = 553; + ClientMessage encoded = CacheContainsKeyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheCreateConfigCodec_decodeRequest() { + int fileClientMessageIndex = 554; + 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 = 555; + ClientMessage encoded = CacheCreateConfigCodec.encodeResponse(aCacheConfigHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheDestroyCodec_decodeRequest() { + int fileClientMessageIndex = 556; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheDestroyCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheDestroyCodec_encodeResponse() { + int fileClientMessageIndex = 557; + ClientMessage encoded = CacheDestroyCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEntryProcessorCodec_decodeRequest() { + int fileClientMessageIndex = 558; + 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 = 559; + ClientMessage encoded = CacheEntryProcessorCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAllCodec_decodeRequest() { + int fileClientMessageIndex = 560; + 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 = 561; + ClientMessage encoded = CacheGetAllCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 562; + 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 = 563; + ClientMessage encoded = CacheGetAndRemoveCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetAndReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 564; + 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 = 565; + ClientMessage encoded = CacheGetAndReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 566; + 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 = 567; + ClientMessage encoded = CacheGetConfigCodec.encodeResponse(aCacheConfigHolder); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheGetCodec_decodeRequest() { + int fileClientMessageIndex = 568; + 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 = 569; + ClientMessage encoded = CacheGetCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateCodec_decodeRequest() { + int fileClientMessageIndex = 570; + 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 = 571; + ClientMessage encoded = CacheIterateCodec.encodeResponse(aListOfIntegerToInteger, aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheListenerRegistrationCodec_decodeRequest() { + int fileClientMessageIndex = 572; + 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 = 573; + ClientMessage encoded = CacheListenerRegistrationCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheLoadAllCodec_decodeRequest() { + int fileClientMessageIndex = 574; + 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 = 575; + ClientMessage encoded = CacheLoadAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheManagementConfigCodec_decodeRequest() { + int fileClientMessageIndex = 576; + 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 = 577; + ClientMessage encoded = CacheManagementConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutIfAbsentCodec_decodeRequest() { + int fileClientMessageIndex = 578; + 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 = 579; + ClientMessage encoded = CachePutIfAbsentCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutCodec_decodeRequest() { + int fileClientMessageIndex = 580; + 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 = 581; + ClientMessage encoded = CachePutCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveEntryListenerCodec_decodeRequest() { + int fileClientMessageIndex = 582; + 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 = 583; + ClientMessage encoded = CacheRemoveEntryListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 584; + 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 = 585; + ClientMessage encoded = CacheRemoveInvalidationListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemoveCodec_decodeRequest() { + int fileClientMessageIndex = 586; + 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 = 587; + ClientMessage encoded = CacheRemoveCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheReplaceCodec_decodeRequest() { + int fileClientMessageIndex = 588; + 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 = 589; + ClientMessage encoded = CacheReplaceCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSizeCodec_decodeRequest() { + int fileClientMessageIndex = 590; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheSizeCodec_encodeResponse() { + int fileClientMessageIndex = 591; + ClientMessage encoded = CacheSizeCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 592; + 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 = 593; + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddPartitionLostListenerCodec_encodeCachePartitionLostEvent() { + int fileClientMessageIndex = 594; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CacheAddPartitionLostListenerCodec.encodeCachePartitionLostEvent(anInt, aUUID); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheRemovePartitionLostListenerCodec_decodeRequest() { + int fileClientMessageIndex = 595; + 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 = 596; + ClientMessage encoded = CacheRemovePartitionLostListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CachePutAllCodec_decodeRequest() { + int fileClientMessageIndex = 597; + 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 = 598; + ClientMessage encoded = CachePutAllCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheIterateEntriesCodec_decodeRequest() { + int fileClientMessageIndex = 599; + 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 = 600; + ClientMessage encoded = CacheIterateEntriesCodec.encodeResponse(aListOfIntegerToInteger, aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_decodeRequest() { + int fileClientMessageIndex = 601; + 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 = 602; + ClientMessage encoded = CacheAddNearCacheInvalidationListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheAddNearCacheInvalidationListenerCodec_encodeCacheInvalidationEvent() { + int fileClientMessageIndex = 603; + 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 = 604; + 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 = 605; + 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 = 606; + ClientMessage encoded = CacheFetchNearCacheInvalidationMetadataCodec.encodeResponse(aListOfStringToListOfIntegerToLong, aListOfIntegerToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_decodeRequest() { + int fileClientMessageIndex = 607; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CacheEventJournalSubscribeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CacheEventJournalSubscribeCodec_encodeResponse() { + int fileClientMessageIndex = 608; + ClientMessage encoded = CacheEventJournalSubscribeCodec.encodeResponse(aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheEventJournalReadCodec_decodeRequest() { + int fileClientMessageIndex = 609; + 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 = 610; + ClientMessage encoded = CacheEventJournalReadCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CacheSetExpiryPolicyCodec_decodeRequest() { + int fileClientMessageIndex = 611; + 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 = 612; + ClientMessage encoded = CacheSetExpiryPolicyCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionClearRemoteCodec_decodeRequest() { + int fileClientMessageIndex = 613; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anXid, XATransactionClearRemoteCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionClearRemoteCodec_encodeResponse() { + int fileClientMessageIndex = 614; + ClientMessage encoded = XATransactionClearRemoteCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCollectTransactionsCodec_decodeRequest() { + int fileClientMessageIndex = 615; + } + + @Test + public void test_XATransactionCollectTransactionsCodec_encodeResponse() { + int fileClientMessageIndex = 616; + ClientMessage encoded = XATransactionCollectTransactionsCodec.encodeResponse(aListOfXids); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionFinalizeCodec_decodeRequest() { + int fileClientMessageIndex = 617; + 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 = 618; + ClientMessage encoded = XATransactionFinalizeCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 619; + 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 = 620; + ClientMessage encoded = XATransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 621; + 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 = 622; + ClientMessage encoded = XATransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionPrepareCodec_decodeRequest() { + int fileClientMessageIndex = 623; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionPrepareCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionPrepareCodec_encodeResponse() { + int fileClientMessageIndex = 624; + ClientMessage encoded = XATransactionPrepareCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_XATransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 625; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, XATransactionRollbackCodec.decodeRequest(fromFile))); + } + + @Test + public void test_XATransactionRollbackCodec_encodeResponse() { + int fileClientMessageIndex = 626; + ClientMessage encoded = XATransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCommitCodec_decodeRequest() { + int fileClientMessageIndex = 627; + 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 = 628; + ClientMessage encoded = TransactionCommitCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionCreateCodec_decodeRequest() { + int fileClientMessageIndex = 629; + 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 = 630; + ClientMessage encoded = TransactionCreateCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_TransactionRollbackCodec_decodeRequest() { + int fileClientMessageIndex = 631; + 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 = 632; + ClientMessage encoded = TransactionRollbackCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateWithValueCodec_decodeRequest() { + int fileClientMessageIndex = 633; + 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 = 634; + ClientMessage encoded = ContinuousQueryPublisherCreateWithValueCodec.encodeResponse(aListOfDataToData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryPublisherCreateCodec_decodeRequest() { + int fileClientMessageIndex = 635; + 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 = 636; + ClientMessage encoded = ContinuousQueryPublisherCreateCodec.encodeResponse(aListOfData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryMadePublishableCodec_decodeRequest() { + int fileClientMessageIndex = 637; + 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 = 638; + ClientMessage encoded = ContinuousQueryMadePublishableCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_decodeRequest() { + int fileClientMessageIndex = 639; + 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 = 640; + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheSingleEvent() { + int fileClientMessageIndex = 641; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheSingleEvent(aQueryCacheEventData); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryAddListenerCodec_encodeQueryCacheBatchEvent() { + int fileClientMessageIndex = 642; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = ContinuousQueryAddListenerCodec.encodeQueryCacheBatchEvent(aListOfQueryCacheEventData, aString, anInt); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQuerySetReadCursorCodec_decodeRequest() { + int fileClientMessageIndex = 643; + 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 = 644; + ClientMessage encoded = ContinuousQuerySetReadCursorCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ContinuousQueryDestroyCacheCodec_decodeRequest() { + int fileClientMessageIndex = 645; + 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 = 646; + ClientMessage encoded = ContinuousQueryDestroyCacheCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferSizeCodec_decodeRequest() { + int fileClientMessageIndex = 647; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferSizeCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferSizeCodec_encodeResponse() { + int fileClientMessageIndex = 648; + ClientMessage encoded = RingbufferSizeCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferTailSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 649; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferTailSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferTailSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 650; + ClientMessage encoded = RingbufferTailSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferHeadSequenceCodec_decodeRequest() { + int fileClientMessageIndex = 651; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferHeadSequenceCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferHeadSequenceCodec_encodeResponse() { + int fileClientMessageIndex = 652; + ClientMessage encoded = RingbufferHeadSequenceCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 653; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 654; + ClientMessage encoded = RingbufferCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_decodeRequest() { + int fileClientMessageIndex = 655; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, RingbufferRemainingCapacityCodec.decodeRequest(fromFile))); + } + + @Test + public void test_RingbufferRemainingCapacityCodec_encodeResponse() { + int fileClientMessageIndex = 656; + ClientMessage encoded = RingbufferRemainingCapacityCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddCodec_decodeRequest() { + int fileClientMessageIndex = 657; + 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 = 658; + ClientMessage encoded = RingbufferAddCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadOneCodec_decodeRequest() { + int fileClientMessageIndex = 659; + 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 = 660; + ClientMessage encoded = RingbufferReadOneCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferAddAllCodec_decodeRequest() { + int fileClientMessageIndex = 661; + 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 = 662; + ClientMessage encoded = RingbufferAddAllCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_RingbufferReadManyCodec_decodeRequest() { + int fileClientMessageIndex = 663; + 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 = 664; + ClientMessage encoded = RingbufferReadManyCodec.encodeResponse(anInt, aListOfData, aLongArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 665; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 666; + ClientMessage encoded = DurableExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 667; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, DurableExecutorIsShutdownCodec.decodeRequest(fromFile))); + } + + @Test + public void test_DurableExecutorIsShutdownCodec_encodeResponse() { + int fileClientMessageIndex = 668; + ClientMessage encoded = DurableExecutorIsShutdownCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 669; + 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 = 670; + ClientMessage encoded = DurableExecutorSubmitToPartitionCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveResultCodec_decodeRequest() { + int fileClientMessageIndex = 671; + 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 = 672; + ClientMessage encoded = DurableExecutorRetrieveResultCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 673; + 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 = 674; + ClientMessage encoded = DurableExecutorDisposeResultCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DurableExecutorRetrieveAndDisposeResultCodec_decodeRequest() { + int fileClientMessageIndex = 675; + 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 = 676; + ClientMessage encoded = DurableExecutorRetrieveAndDisposeResultCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorAddCodec_decodeRequest() { + int fileClientMessageIndex = 677; + 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 = 678; + ClientMessage encoded = CardinalityEstimatorAddCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_decodeRequest() { + int fileClientMessageIndex = 679; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CardinalityEstimatorEstimateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CardinalityEstimatorEstimateCodec_encodeResponse() { + int fileClientMessageIndex = 680; + ClientMessage encoded = CardinalityEstimatorEstimateCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorShutdownCodec_decodeRequest() { + int fileClientMessageIndex = 681; + 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 = 682; + ClientMessage encoded = ScheduledExecutorShutdownCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 683; + 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 = 684; + ClientMessage encoded = ScheduledExecutorSubmitToPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorSubmitToMemberCodec_decodeRequest() { + int fileClientMessageIndex = 685; + 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 = 686; + ClientMessage encoded = ScheduledExecutorSubmitToMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_decodeRequest() { + int fileClientMessageIndex = 687; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, ScheduledExecutorGetAllScheduledFuturesCodec.decodeRequest(fromFile))); + } + + @Test + public void test_ScheduledExecutorGetAllScheduledFuturesCodec_encodeResponse() { + int fileClientMessageIndex = 688; + ClientMessage encoded = ScheduledExecutorGetAllScheduledFuturesCodec.encodeResponse(aListOfScheduledTaskHandler); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetStatsFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 689; + 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 = 690; + 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 = 691; + 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 = 692; + 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 = 693; + 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 = 694; + ClientMessage encoded = ScheduledExecutorGetDelayFromPartitionCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetDelayFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 695; + 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 = 696; + ClientMessage encoded = ScheduledExecutorGetDelayFromMemberCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 697; + 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 = 698; + ClientMessage encoded = ScheduledExecutorCancelFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorCancelFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 699; + 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 = 700; + ClientMessage encoded = ScheduledExecutorCancelFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 701; + 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 = 702; + ClientMessage encoded = ScheduledExecutorIsCancelledFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsCancelledFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 703; + 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 = 704; + ClientMessage encoded = ScheduledExecutorIsCancelledFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 705; + 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 = 706; + ClientMessage encoded = ScheduledExecutorIsDoneFromPartitionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorIsDoneFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 707; + 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 = 708; + ClientMessage encoded = ScheduledExecutorIsDoneFromMemberCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 709; + 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 = 710; + ClientMessage encoded = ScheduledExecutorGetResultFromPartitionCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorGetResultFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 711; + 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 = 712; + ClientMessage encoded = ScheduledExecutorGetResultFromMemberCodec.encodeResponse(aData); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromPartitionCodec_decodeRequest() { + int fileClientMessageIndex = 713; + 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 = 714; + ClientMessage encoded = ScheduledExecutorDisposeFromPartitionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_ScheduledExecutorDisposeFromMemberCodec_decodeRequest() { + int fileClientMessageIndex = 715; + 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 = 716; + ClientMessage encoded = ScheduledExecutorDisposeFromMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMultiMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 717; + 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 = 718; + ClientMessage encoded = DynamicConfigAddMultiMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddRingbufferConfigCodec_decodeRequest() { + int fileClientMessageIndex = 719; + 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 = 720; + ClientMessage encoded = DynamicConfigAddRingbufferConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCardinalityEstimatorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 721; + 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 = 722; + ClientMessage encoded = DynamicConfigAddCardinalityEstimatorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddListConfigCodec_decodeRequest() { + int fileClientMessageIndex = 723; + 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 = 724; + ClientMessage encoded = DynamicConfigAddListConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddSetConfigCodec_decodeRequest() { + int fileClientMessageIndex = 725; + 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 = 726; + ClientMessage encoded = DynamicConfigAddSetConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReplicatedMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 727; + 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 = 728; + ClientMessage encoded = DynamicConfigAddReplicatedMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 729; + 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 = 730; + ClientMessage encoded = DynamicConfigAddTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 731; + 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 = 732; + ClientMessage encoded = DynamicConfigAddExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddDurableExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 733; + 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 = 734; + ClientMessage encoded = DynamicConfigAddDurableExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 735; + 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)); + } + + @Test + public void test_DynamicConfigAddScheduledExecutorConfigCodec_encodeResponse() { + int fileClientMessageIndex = 736; + ClientMessage encoded = DynamicConfigAddScheduledExecutorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddQueueConfigCodec_decodeRequest() { + int fileClientMessageIndex = 737; + 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 = 738; + ClientMessage encoded = DynamicConfigAddQueueConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 739; + 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)); + } + + @Test + public void test_DynamicConfigAddMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 740; + ClientMessage encoded = DynamicConfigAddMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddReliableTopicConfigCodec_decodeRequest() { + int fileClientMessageIndex = 741; + 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 = 742; + ClientMessage encoded = DynamicConfigAddReliableTopicConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_decodeRequest() { + int fileClientMessageIndex = 743; + 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)); + } + + @Test + public void test_DynamicConfigAddCacheConfigCodec_encodeResponse() { + int fileClientMessageIndex = 744; + ClientMessage encoded = DynamicConfigAddCacheConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddFlakeIdGeneratorConfigCodec_decodeRequest() { + int fileClientMessageIndex = 745; + 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 = 746; + ClientMessage encoded = DynamicConfigAddFlakeIdGeneratorConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_DynamicConfigAddPNCounterConfigCodec_decodeRequest() { + int fileClientMessageIndex = 747; + 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 = 748; + ClientMessage encoded = DynamicConfigAddPNCounterConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_FlakeIdGeneratorNewIdBatchCodec_decodeRequest() { + int fileClientMessageIndex = 749; + 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 = 750; + ClientMessage encoded = FlakeIdGeneratorNewIdBatchCodec.encodeResponse(aLong, aLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetCodec_decodeRequest() { + int fileClientMessageIndex = 751; + 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 = 752; + ClientMessage encoded = PNCounterGetCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterAddCodec_decodeRequest() { + int fileClientMessageIndex = 753; + 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 = 754; + ClientMessage encoded = PNCounterAddCodec.encodeResponse(aLong, aListOfUuidToLong, anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_decodeRequest() { + int fileClientMessageIndex = 755; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, PNCounterGetConfiguredReplicaCountCodec.decodeRequest(fromFile))); + } + + @Test + public void test_PNCounterGetConfiguredReplicaCountCodec_encodeResponse() { + int fileClientMessageIndex = 756; + ClientMessage encoded = PNCounterGetConfiguredReplicaCountCodec.encodeResponse(anInt); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_decodeRequest() { + int fileClientMessageIndex = 757; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, CPGroupCreateCPGroupCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPGroupCreateCPGroupCodec_encodeResponse() { + int fileClientMessageIndex = 758; + ClientMessage encoded = CPGroupCreateCPGroupCodec.encodeResponse(aRaftGroupId); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPGroupDestroyCPObjectCodec_decodeRequest() { + int fileClientMessageIndex = 759; + 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 = 760; + ClientMessage encoded = CPGroupDestroyCPObjectCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCreateSessionCodec_decodeRequest() { + int fileClientMessageIndex = 761; + 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 = 762; + ClientMessage encoded = CPSessionCreateSessionCodec.encodeResponse(aLong, aLong, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionCloseSessionCodec_decodeRequest() { + int fileClientMessageIndex = 763; + 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 = 764; + ClientMessage encoded = CPSessionCloseSessionCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionHeartbeatSessionCodec_decodeRequest() { + int fileClientMessageIndex = 765; + 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 = 766; + ClientMessage encoded = CPSessionHeartbeatSessionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_decodeRequest() { + int fileClientMessageIndex = 767; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aRaftGroupId, CPSessionGenerateThreadIdCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSessionGenerateThreadIdCodec_encodeResponse() { + int fileClientMessageIndex = 768; + ClientMessage encoded = CPSessionGenerateThreadIdCodec.encodeResponse(aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCReadMetricsCodec_decodeRequest() { + int fileClientMessageIndex = 769; + 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 = 770; + ClientMessage encoded = MCReadMetricsCodec.encodeResponse(aListOfLongToByteArray, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterStateCodec_decodeRequest() { + int fileClientMessageIndex = 771; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anInt, MCChangeClusterStateCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCChangeClusterStateCodec_encodeResponse() { + int fileClientMessageIndex = 772; + ClientMessage encoded = MCChangeClusterStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 773; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCGetMapConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetMapConfigCodec_encodeResponse() { + int fileClientMessageIndex = 774; + ClientMessage encoded = MCGetMapConfigCodec.encodeResponse(anInt, anInt, anInt, anInt, anInt, anInt, anInt, aBoolean, anInt, aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCUpdateMapConfigCodec_decodeRequest() { + int fileClientMessageIndex = 775; + 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 = 776; + ClientMessage encoded = MCUpdateMapConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetMemberConfigCodec_decodeRequest() { + int fileClientMessageIndex = 777; + } + + @Test + public void test_MCGetMemberConfigCodec_encodeResponse() { + int fileClientMessageIndex = 778; + ClientMessage encoded = MCGetMemberConfigCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunGcCodec_decodeRequest() { + int fileClientMessageIndex = 779; + } + + @Test + public void test_MCRunGcCodec_encodeResponse() { + int fileClientMessageIndex = 780; + ClientMessage encoded = MCRunGcCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetThreadDumpCodec_decodeRequest() { + int fileClientMessageIndex = 781; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, MCGetThreadDumpCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCGetThreadDumpCodec_encodeResponse() { + int fileClientMessageIndex = 782; + ClientMessage encoded = MCGetThreadDumpCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownMemberCodec_decodeRequest() { + int fileClientMessageIndex = 783; + } + + @Test + public void test_MCShutdownMemberCodec_encodeResponse() { + int fileClientMessageIndex = 784; + ClientMessage encoded = MCShutdownMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteLiteMemberCodec_decodeRequest() { + int fileClientMessageIndex = 785; + } + + @Test + public void test_MCPromoteLiteMemberCodec_encodeResponse() { + int fileClientMessageIndex = 786; + ClientMessage encoded = MCPromoteLiteMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetSystemPropertiesCodec_decodeRequest() { + int fileClientMessageIndex = 787; + } + + @Test + public void test_MCGetSystemPropertiesCodec_encodeResponse() { + int fileClientMessageIndex = 788; + ClientMessage encoded = MCGetSystemPropertiesCodec.encodeResponse(aListOfStringToString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetTimedMemberStateCodec_decodeRequest() { + int fileClientMessageIndex = 789; + } + + @Test + public void test_MCGetTimedMemberStateCodec_encodeResponse() { + int fileClientMessageIndex = 790; + ClientMessage encoded = MCGetTimedMemberStateCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCMatchMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 791; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aString, MCMatchMCConfigCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCMatchMCConfigCodec_encodeResponse() { + int fileClientMessageIndex = 792; + ClientMessage encoded = MCMatchMCConfigCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCApplyMCConfigCodec_decodeRequest() { + int fileClientMessageIndex = 793; + 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 = 794; + ClientMessage encoded = MCApplyMCConfigCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetClusterMetadataCodec_decodeRequest() { + int fileClientMessageIndex = 795; + } + + @Test + public void test_MCGetClusterMetadataCodec_encodeResponse() { + int fileClientMessageIndex = 796; + ClientMessage encoded = MCGetClusterMetadataCodec.encodeResponse(aByte, aString, aString, aLong); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCShutdownClusterCodec_decodeRequest() { + int fileClientMessageIndex = 797; + } + + @Test + public void test_MCShutdownClusterCodec_encodeResponse() { + int fileClientMessageIndex = 798; + ClientMessage encoded = MCShutdownClusterCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeClusterVersionCodec_decodeRequest() { + int fileClientMessageIndex = 799; + 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 = 800; + ClientMessage encoded = MCChangeClusterVersionCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunScriptCodec_decodeRequest() { + int fileClientMessageIndex = 801; + 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 = 802; + ClientMessage encoded = MCRunScriptCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRunConsoleCommandCodec_decodeRequest() { + int fileClientMessageIndex = 803; + 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 = 804; + ClientMessage encoded = MCRunConsoleCommandCodec.encodeResponse(aString); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCChangeWanReplicationStateCodec_decodeRequest() { + int fileClientMessageIndex = 805; + 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 = 806; + ClientMessage encoded = MCChangeWanReplicationStateCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCClearWanQueuesCodec_decodeRequest() { + int fileClientMessageIndex = 807; + 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 = 808; + ClientMessage encoded = MCClearWanQueuesCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCAddWanBatchPublisherConfigCodec_decodeRequest() { + int fileClientMessageIndex = 809; + 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 = 810; + ClientMessage encoded = MCAddWanBatchPublisherConfigCodec.encodeResponse(aListOfStrings, aListOfStrings); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCWanSyncMapCodec_decodeRequest() { + int fileClientMessageIndex = 811; + 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 = 812; + ClientMessage encoded = MCWanSyncMapCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCCheckWanConsistencyCodec_decodeRequest() { + int fileClientMessageIndex = 813; + 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 = 814; + ClientMessage encoded = MCCheckWanConsistencyCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPollMCEventsCodec_decodeRequest() { + int fileClientMessageIndex = 815; + } + + @Test + public void test_MCPollMCEventsCodec_encodeResponse() { + int fileClientMessageIndex = 816; + ClientMessage encoded = MCPollMCEventsCodec.encodeResponse(aListOfMCEvents); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCGetCPMembersCodec_decodeRequest() { + int fileClientMessageIndex = 817; + } + + @Test + public void test_MCGetCPMembersCodec_encodeResponse() { + int fileClientMessageIndex = 818; + ClientMessage encoded = MCGetCPMembersCodec.encodeResponse(aListOfUUIDToUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCPromoteToCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 819; + } + + @Test + public void test_MCPromoteToCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 820; + ClientMessage encoded = MCPromoteToCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCRemoveCPMemberCodec_decodeRequest() { + int fileClientMessageIndex = 821; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, MCRemoveCPMemberCodec.decodeRequest(fromFile))); + } + + @Test + public void test_MCRemoveCPMemberCodec_encodeResponse() { + int fileClientMessageIndex = 822; + ClientMessage encoded = MCRemoveCPMemberCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCResetCPSubsystemCodec_decodeRequest() { + int fileClientMessageIndex = 823; + } + + @Test + public void test_MCResetCPSubsystemCodec_encodeResponse() { + int fileClientMessageIndex = 824; + ClientMessage encoded = MCResetCPSubsystemCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerPartialStartCodec_decodeRequest() { + int fileClientMessageIndex = 825; + } + + @Test + public void test_MCTriggerPartialStartCodec_encodeResponse() { + int fileClientMessageIndex = 826; + ClientMessage encoded = MCTriggerPartialStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerForceStartCodec_decodeRequest() { + int fileClientMessageIndex = 827; + } + + @Test + public void test_MCTriggerForceStartCodec_encodeResponse() { + int fileClientMessageIndex = 828; + ClientMessage encoded = MCTriggerForceStartCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 829; + } + + @Test + public void test_MCTriggerHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 830; + ClientMessage encoded = MCTriggerHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_decodeRequest() { + int fileClientMessageIndex = 831; + } + + @Test + public void test_MCInterruptHotRestartBackupCodec_encodeResponse() { + int fileClientMessageIndex = 832; + ClientMessage encoded = MCInterruptHotRestartBackupCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlExecuteCodec_decodeRequest() { + int fileClientMessageIndex = 833; + 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)); + } + + @Test + public void test_SqlExecuteCodec_encodeResponse() { + int fileClientMessageIndex = 834; + ClientMessage encoded = SqlExecuteCodec.encodeResponse(anSqlQueryId, aListOfSqlColumnMetadata, aListOfListOfData, aBoolean, aLong, anSqlError); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlFetchCodec_decodeRequest() { + int fileClientMessageIndex = 835; + 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 = 836; + ClientMessage encoded = SqlFetchCodec.encodeResponse(aListOfListOfData, aBoolean, anSqlError); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_SqlCloseCodec_decodeRequest() { + int fileClientMessageIndex = 837; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(anSqlQueryId, SqlCloseCodec.decodeRequest(fromFile))); + } + + @Test + public void test_SqlCloseCodec_encodeResponse() { + int fileClientMessageIndex = 838; + ClientMessage encoded = SqlCloseCodec.encodeResponse(); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 839; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 840; + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddMembershipListenerCodec_encodeMembershipEventEvent() { + int fileClientMessageIndex = 841; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddMembershipListenerCodec.encodeMembershipEventEvent(aCpMember, aByte); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_decodeRequest() { + int fileClientMessageIndex = 842; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveMembershipListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveMembershipListenerCodec_encodeResponse() { + int fileClientMessageIndex = 843; + ClientMessage encoded = CPSubsystemRemoveMembershipListenerCodec.encodeResponse(aBoolean); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 844; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aBoolean, CPSubsystemAddGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 845; + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeResponse(aUUID); + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemAddGroupAvailabilityListenerCodec_encodeGroupAvailabilityEventEvent() { + int fileClientMessageIndex = 846; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + ClientMessage encoded = CPSubsystemAddGroupAvailabilityListenerCodec.encodeGroupAvailabilityEventEvent(aRaftGroupId, aListOfCpMembers, aListOfCpMembers); + compareClientMessages(fromFile, encoded); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_decodeRequest() { + int fileClientMessageIndex = 847; + ClientMessage fromFile = clientMessages.get(fileClientMessageIndex); + assertTrue(isEqual(aUUID, CPSubsystemRemoveGroupAvailabilityListenerCodec.decodeRequest(fromFile))); + } + + @Test + public void test_CPSubsystemRemoveGroupAvailabilityListenerCodec_encodeResponse() { + int fileClientMessageIndex = 848; + ClientMessage encoded = CPSubsystemRemoveGroupAvailabilityListenerCodec.encodeResponse(aBoolean); + 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/resources/2.1.protocol.compatibility.binary b/hazelcast/src/test/resources/2.1.protocol.compatibility.binary index 018bfd7c0c8b33779cbace2b7e4b64c7f418e69c..30b2784b04762973cf38458d1491c21cfdda376b 100644 GIT binary patch delta 14 VcmbQ+!2IDa(}pDW&HWsG+W|9*2DktK delta 156 zcmezHmuYST^M)jL4siw`c)%byS&&tXNswW3VXHK!6iDn4h}YjQ&L#)qF-*R07(ZUA^-pY diff --git a/hazelcast/src/test/resources/2.1.protocol.compatibility.null.binary b/hazelcast/src/test/resources/2.1.protocol.compatibility.null.binary index 6a14a5b7ff944109282bb66a0634006343f6fce4..e671ea69e00ee59ae918dc6e459e3c64a04c2c1c 100644 GIT binary patch delta 14 WcmbPtj_KoRrVT>uo9#L7&jSE5vIcDc delta 171 zcmex(nrYrSrVT>u9O4W>@PI*Z@vj% zUcVp|xb@mQ1NO}rGEPo+sH%Q^Ce#G0US&m`I1w2cnK$oHH?IHdoDXmO_rLw0d-})U z9*2*A_~uVvhWFd6@alf|`+xh_-+lA@fB%mIemn}mn+%W|Z+;oR>O7Ehw8~;rT21ROSh{nAJ7WeD*v*7C1Eyd;jEqMKyT0OM7 zw?fn10-Azg2rhfWuWtmYT|1;2mTK3r5sZCDZEkLH~)G(K5o>vBQ+U2zfK1TT@JKptQmWz;wCdn`mx=j-YqK_)d5;$m`~s~Q%p+kK1w|+2{5)EJ6t6_;K7}1Dc z-oM?>gOO%ckRHCee?D6eM%<@73vGt&&de~0H-NgIvz>?2?98+$84cjE2t7&-&Kn}2 z95eNC3aCu=eWC%05P)fIc#`7J!RtII^D@w?iX1;Z9fT)qrXz6$9p~TSj(nEl_^`tA zHL^46gRE2mx?Cr|4Ce0^AfxNVV$l^S4X&43)LQM=<$6G(@qB7DDiGo|Ks3Dunb*PV zH}>}$Aevr-%Xwy58`A)r~Bbm;uDiNL(C> z5P?(~qEEtL|8@Z~%@7IwcT%Gh>4R2W`@NeY&8+Wl2j-mzka+BR6u#R0OL&cKioWmr z+;T@;Zsb7Vy}dk^xdK4q9Q=L?oTZRVg&@TH2%Wo5_3{i7MUYa(4{C}o?tOC)v|`0E z5pY1#3Hk>qc+H#6gOHnIPG;v1E7&{m?mPgE*dGpq@cO92%Z4(=s`DT;Vv|EG*ncqv z8-zx%C;9WDV$9@E{UHX?_(2`=h(d2$0jI`*qjve9}aTiLBgB6L6C-( zbqRl6Ym^fq!Yl zTkV{4;we~APyZ@4S}R{$4??g9d%0PrRc>GdC{ zJZf=h`wPm47+Rl=b8+Rd%SfL9=pi`%WG9ZpV*ql!^I%{vzLIA@P5BPxd#j(f9zb;b z{Vc`J@`nB8Mm@>F=a4pB;X>nZP+CKfw73wSv}ESCCmjHujZg$Chji;khUQ;?Z$k{8 zeYYY0`S&)&;MqusTZ84kvYSqkcJA{u^r0YRMTE`?Uu*f0RV%1DK5481#CJ334POh= zxnJyN8`Ngm9_A#Y{fm@S77K!C73j``^4Ns`<+z>slPrLa+5c+Xe%nt_9?5Dh=@Q#t zj@z8?Gk{LwB3nCulX5Axb~uf*?q_dg2mpc@&ZPPLd>9ux-IM+a?dH&cDy&MN{x&6- z;SMI@)`PO+jU)G~6faQ9w?AZ$5hTkEw6A-;ezzQC!UkI5MA4w`w}_M1cgqZydth+T zp3tFGNwm?-l}y=40sOj*O&0I8zO@LooRe$;GgH#^B(1uV7r#!q5>Gp>{4jLS)`L(? zJoWiS5b50Cr8xSnmhjB~xgNhyMm!jy<6E^drC-yYk~Q>i>a1&QE2T@0oB_o7PdOZa zUk6sg`d%|Mzg~f{W{nnJ|L`h#fw3`O|M)6-fw3`O|MV((fw3kpNnCGNB!_}|pnQ^q z2Jm>cVKLocWu!>O0+1;cOZWYkhp-JGlWa?UT&1?N`Y3*Z&>Zab6l@ThgMBmw8-zx% zTLqgculCb%YI7(lD>)*`2O#nM%t;DdtD0>

$JrngR|nol%a(0|1X6oTUb{G?MLG z5W?--2ZOqlg8j9`CZrpp=hieile63;-aq${3*%y;UU9JgGho)tmPl2x)CwBo8~ zlOpM`%HIjlPMx%JMKT*e<3(E2?5N#|_QbJ=1|Em+BWnviHV+V#?INudP?_rcL<16` z#|EZj|A{pP!n@%Dh~hq-jyu0_0(h*{&!!u!j9m#3faosw^AtA=_=E$B;r*!ed>$Cn zK*G&jJ9LnwDuBdPggQq=362jS*&T2^^SDJ})AzyqN%yyGc&AT)+|G6fHWMpkpYY7^g2r(lE7By8CU zIZLs_bX|`v2u{Km?hjJ@iODVr2Fh{toDTv{C<`|N4nPt7;!xlK6u~bK1r9(F{Hg+; zjgS7SZ4=Vsv9YE~0hkd^0CHYdWDiqtS%VraS&@NQxgw(r`0f@U6L=O&pt#Pg%rUZx zdX%y$AhNudGy$y`?8hlmrYIE`gs|d18PpY{AQX-IRajrsU!|u;rVUWmE8G?-USn?< zq{_Z|8Q9z{KqfHLnqLIC#ZmfanG!10voK4jKr4o7l_HU%+vVCl0MY^D?N;E}4VKZ; z_aKCQzo_UMuU2@(QBaPKE(ZZ;j9vhW;HyFK5w@Tl0oVHgf^q~r8U&o-J^)4V<3oW1 zPy|0Y6gU7y@Y4#orKqg9K}b{kY+SGNAT((mKzY)+2Pt-IDgd#v+{jb_GGPQ3bz;I) zaGtU$AnK(Cv|_9;Qlz>f2stkcugg?1F1)NB%*bB=iw3S52C_`(JP0;dxk7r=z%iyj?O)5U=}d}!6r{x;XY0=v&p6v4_zdfGENjvtT|3H<1rRY zP$o<{A@MZD3<(#LuJ9j(CyjE6#k15#HX0-cKxh)SWU!b{O6(9`=@anQ}2hD;DsIy z>3iW7+1XGLDlXl~CKD3PAHzkL`)oa!jWE9oB>E?G&19rh55x@2M`jYMdO(f7hcwm@>$}cD_GG4zJ6Y1n0LRBSiQZyRPv;pEa{h++xuvxQ zgGF+BjhM+f{{`!=tgWis1Or9qKMr7>TaSQcBcW9WWQhT2&5H30HheTK`(J*o9CvAHs zoTfM*56qsJrw>3g*&Kjc-c2;H+bsbyV)IY_E{sJ?&84*+j9Fy|UuPk+78$IpZFdG% z2c$XzYO{0bkg%V*QUdp#HejyFOzJi~zA%Jl_quK2k&Xal=V__auQKgniNRViZyu_O z2n8_bJnanjN6jM?4iN!agn=nN%37t?cN?V^YT0oBRNQe`--|IoC1aXM_5jO6Cz2sM z{~MlY7uFW6Y2N62kyxQu^~-&OuE}K-od1exEv;=btpm{k)A2BKHIvT1R5TsUEMbSt6scZq0`zH_$ZX{tq0U{ z6OxuOcMFgS2^}Vv>WnitQiJl9OqbQ=g9(ACXp6(3U3wu7gUsvT@cCX2gLczlka-;( zzNk5DV?=rqq?(R_%y;UTZ0TL5juoRQn`dOM0IgVwuTrE;Q7SG7$@Wxh$Z^q<$!{|S z8-(UyKb(RMLL=D2{?NDmDelx}>wFA|HS-B%zSDf7Le=ll&<&!Y9@B}HBA@gafYM{~ zQUXxzQ1-BvBtaL3+MKGz)uoAs$nWc_5CGIM0;@R$tXSzmf@#xQQM_7P^SDE6&LOjzL#BuTXwNbFaE{T*5dhRVWF8%sjErnR zjoBv0w>vFu=I1+Diwxk0duEs8cIpA@oWL)6I@~E7Z8Cs5hsPG5Ap>Qo zk^aKk4rmEbqb2w?t#M0bpo}L4>hn+)`h!9HA*?~rp_PASY-nZ~dURu9ZG#qR{FocE zA^`2?Dob2jPBfIbRu}}7F@vjv7zC82!I#{5>xl-lP-@{aZORC0?lXcS9SqR+08erj z7THGwsdC?gE`PaOfK2G=umx;qj%mTR;j^#d(L*ws#=FZ}n>2IV$&TEluIFh|53}gd zms`IuA-(HiX-(=6>AFaoooZ2}Z*`L&z!ZPgz_;KFHxSel1nX2c<3)_x!xWU`6S0p{ zK)D=)#x?a~=t)n1nXOqLIbeL{M?jpVJQ!#0@(o{&nkQFghFR1a8HFzuwr=Q>&PKvc#HtAbIYla(z7>-ZLa$mQgvuFSa+vAMyJYb5 zm0z`Pg?Vl}ci{Igo1};zr}c@Fuqc!uq($~5)vFYp-2&axqHfS30LGhhyZCpS@~jQA zkq5I7qe{^y;Ld}Ak;AxQ*W}u!vy^Wuu5CU5(2R}PdN9qFEBESJu8hPA3^ut*zn!Pt zvVN$jKz6k%5 zc>mL!rZ(%ziSr7-uegB{rgVQT&Hr7NIGC*Q8T$p(>*m^*6 zKVAiS}D?MuaF}God+V# zPLtyHM#`Cz$@)lkHb96fjO=W@nd&xnHbAP}+4v-k({C3bqdNgb`bd_&l^QL?G7qG? zKr43F+bL2dH-?K(Yow7D{|-&7i?$w&YlV4dluxzJgW9Y*KS=*Zy7=9cQ=^MPs_f#g zLl@sIKqho?(QidVvW;kKm{!%Ke7;*|X0qZq+@aiY46O($O<--=Do&{vuc~!(?mf_fx@bc`1ezC*?9Rd^w!pcP&A;1UIdZOU8gwuZJ<;c zO08^bb*DVHAB+&HTHy$`Ksgj?*NFEYq^z^3PJwMPmP!K#;&p<2w{i#@Z2_|t+cn}n zwOe_kZ*@%rn!Gc)bqg{S!N{M^L#rgr1S_(iBx8M<0?Q8NB$}Y=Xyv$ds}!xsM&8Ws z??g8_eZuM5nnI~a`+S&>?4|=kIg)9RZrxF8r65Rw-FgsnqIo<`6U5xh&|h2UpHjbt zmueAISH(7n^RLu_bWI5D=T_KT?d&-n+}&Ib@i?@yOrXiWf5eKcO@f#*C;R=)ul7~w#=1TT<@(Dh`XH3+ zucqjOP_Dn8q7On*U-nLpQvHx#Szl0=R@UhfTL6gIk~7CCwnjdSu~ab-ZXS{eXZ<0m zo@?l{3TGZ0!{bZ%16bt$A|y)ZPV4-2SWk?TEYtw(Fbg$)R&QWRQK&_=&wP#nNomGg zQzhf2b}mdP4z;DVMMayl=*vo)Pz?KGY|7-mbmhvLldiO4F6jY+W9hM;hPm}1sE3$G z({%fDize9QBg23;p{NI_qlSh--(exU^O;r(ie<7(gPyixhYg4(LRJmnqI}1OX%xyh?$G3CgquI?ZW9 za&(iz&*Uxk0HkS8hS<#WTYdtOgeGh_o<*aKDfqfmPL!-|xBAfEqUgU)?84rs-dikT*_M5bSQ zz=6p?vX3N#2ZY9qB#Rh;!|n%xbU%ByV~|;^eJm^hoaWxDZK0MX>^Q%^io5`N%6R>H zGX{F@9qz@Wlrb+*YaNzlhAm~?#1=lI8?LmcCQ zDwVKW_zJH;+0jXdewmSag%u_Dk4zMp0H7Ip*2ZjdwZ5&J0Zd0HF#Deo7%>xUWnnp7 z7uBy^{r^*3A$ab`A)7jPJ|Uj%8ffPTvX~ElY|S*(Q+bewp$^!&2ZYKvGcw;U#D%Yt zrmdi4SS>NOkqKuXNhXgkH?lh4YGV|u)xbtAE4_*&U`y;yT*6hoLw6>POoUGFhmds( z3-BxZ8gBcj8Q;_z8D%r9iKaxM%ByW4(c&{rNnIa1IW)!GVD2S;R`NTeo_(AG%@p@s zaWM$L4)@6+dsF&%j?Tg0xG7GvYO;D;vCW z5Cq(GX>pm-4fpOOsht^kO+MaV1R2?qmp}7`D!LyRN))wA<{=wRtl>bF+HCP&hV~&V zHML}clM)FZu#{xw?-{9#e ztEXv42$}B3;k*94fC)yIlzH%k#QI&6cY`?nP1%j1lu$FzY#-= z)DTw$`Yw8`K_wCvLLNd{V~uEk_o*4tb03~U939-vt_>(U5bP7#Pz(C%hMYKCm}p35 z{dO)9{oPoAi%)W09>|1Df&iycT%{Iflc!?SUj=3`F>EhG-)x<~?%(*YI_5QQgw%O| zEyDeqe#NY~nBUR|ejwDf3eYBRe{q%R22-I3i0AN)dcI7Bv%LFRuj@JwLd6cLR_O3< z$Ff;Qb#9f~DYQaEW?V>vCX?Q}bqXfK7+P~E8i@VHauvP)+Bj?F+c~!G*qTBJ`6|E8 zLvzEzNvbF=K&!fNS`~y=6+Ej5_CF_Otx~cmcve-ikCZN4tG4ceDF^Q)e9&5TuHVi` z^|J1g(@`K4uTj596=Po;UE(Ka18nV8bAp##y1W2n4cKLBjCV*qw7PgkI>V=rmbsEN zS1F!!DYWuAoUPlWg15IK3hm6Xa}QI|VII;ypwsA|M?0W`PL3+4O&_PIw-d;2Jt(Qq zPg0yoFrdSij&|;83WJ3N|6PN(bgO-99WMa~OZ72ENh?R@86uB2D#)FCR#MKyYafk| zTm}m;<@E}(40)cKs^Ml)D9ivv!_3ybk(!Z!L8}Cehjn`J6nZJ+1%cEW^=8!qwDR>X z<+8X~C(AH?s{*+7(8{axt$RBaEbz$L{?->0)5`OXHO0ER_0Xz<@1}xMIiXcfXK&qm zRY_=#lJBRI!V+55_;pnfTJ_YR|G?>Aa7R}et^OOiy;15gfI6>`oF*^GnzpsxAy;P1 z7cxrO(1h(Uk*C!dpRRiP$KTS@>kr@j>B~U0mclnO;1_A+Ld0gf$P42BmI%Xgax=qy zdm*)CX_iC(&-Xxb5O8#T<>~A*^>={wQsJPvEIl+G^^XrqRe2%2p)X4v=G@#`p|52@ z@o`|&FP>BQV)V;c1u?m7ee0H~syYSDB|!@H-2!AR)bw3k{p)zBSwgwEci@!eRIDZutH3KmPGJ zy#D*||MQpO)dQ2;MDjiy>f9o{#GgsN5wgoY&M0SZ$K3)JZa=qP1z)yq$v*Wj!L8@i z>Y>%W7n&Xy&=dqi03+S_`<)=w3hCyI4hEf?$0t?42P97k?&0Bq6j?ojL`xw|1Nu|w zMAZ2EKE`0#jDZ41My~_G+akdz=ABy+efkwbnGvP8ntt3PpyL>3y#oyBI3l@?y%?ba z8-Ex6-o~*Y7V?quHXQhFLC!{*pc?u&{4a*vXF+D`;*bb`Q?3=^c@d6mJ%~BaX?hY4 z#h+k_g3@_tHOW|us7nJHlIEUc5EF{<1H8lln#1b$}Kl)*HCZ6qB60&#cF-+yyb` z-vph0`Jgl~=0YXw`#9r#`Q?{C?f?BG{EGjm{kCkUPU;s1Y9!W-J01`VJ%HA0R@>+R zV$qj}KnD+2{k_=xysbQHm)rds&N}DjHh9Ww{VXm5Bglhoz=k?QD-+D0OzKC!2Fh8H0n@lK@?==H3SLj|-3qqcm7AmPVoRC>-D| z5%~L#y?8yhwVH2vjvDITaej@?Ym93nqVA55N)yonVneCdb)G( zSyn~T)JFhlIZr3KoqOLR`Am~t1F6!r&qH>8w*Z-@YfS$GYjh%g&`K+r4=vKn`t^Qb z-gy8?XHYcE{&cOHO7><@>5dEHfbX=UJr5(tghj3H+1 zKbwLLLL=Cd{CQKcsc{}TDFo#aF2>K#_OS`db8O!4V-u7|Y)*>#4+ptWsCctH2-2|9 zE{TV0jl2aOHw0UnyqC=t1DMF5{!xXTCV1Q`^&mu>y_~?G59)GV1feu5{kc_)^)2_g z728&O%sKWHEQqInVU58KVBJti-f~L84MO*wrk1EZHGeAdGKtc14zvj<#cY>Tm!YJ0oFYa&AF9nLga5;%X zoG!X`?iah+2DMqX2O}(_{cFo9iv>Zn3Uuc|IrjD)*N|V1qt2gF0n}RiX53oa2T&f# z*w~ls;jhMR&i4>NCvo9zkiW8AifxdXqFL8QZ#caHfemNU@rr85d6~*d|AclvXs{Gk zIZ%IX$z`~M3AXj1?BXVi`?bXjl=5v0-fRNNa<%gMK8B(mt*O4TAX*aw{lGgFfC#MV#Fg1@m`iKm|ZeHuDr z>p>``nfUxBh;;66Esh+OVx0L;9TE4t?>;5~4*;}06oe^#Mly2V^qV@9j6o~5e9j6W z&VLbI{JT1^5S7=Oq4^aDjK$8qV-|n^eX;;!mc?(sPZnUzviRNi$pVZq3qGatdV6Ll zRR_ugPDB7td*X}f2HVpsfJAqirzkYK?%CPpA#4N4B->o8R@Qb_t9Zr)p*h&=DcB%1 z2m5FWHVBPix26lzPsi5gP*PTMgp&_I(iM#p3tX#qZ9q^?*?ejNhnUVNqwE2IClAi7 z!7PnX?Dc!M0@Pmje@7)@=V)8q~`&Gvfi3v0fni&PBg#~ zdahtH)?R2+AiNtcfC%o(>A3R?6@aJ8_-eYrO3~l|0f_9?zP7koz-bH*F9wE>+AB_A zOaciXG})npI8^~8r7C<}B>-oRjf^!=mO#NrKN6l+E3V2QgfqoTKQ@wd$HzT82g)fM z))vsDwUVMq>{qAVLgM;3)bRA_^c)jpo04MJA?WQsNjMeX5alkKw8DcB%137gO7 z&n$MB=<0C;!AbbCsId4G)0R`^T$R%}xX`vr?oAlr_Y4j|3H)D4=y-1i`a zeZQ#aDz8>}*ileUjxGlQXOunwO5m$O@DaA4oB-GR0D^J?JQ@U?;XVK*@Z&>)15g4# zITSbmCGgV7)~7t_+_}YW6@Cya%MBNPkO?EOs1rruzp%Co zg?eEDtrXcyi&R$xA?JBfb!8RPqDn{qjBEw4WZ=4CAnW(egJA5xJEpj4ASlJwkmpr6 z09fRk{gAgF0OCjWJNK-CS@;Wr%!=2c&n-eWNwj>G$z7GPz`xMuG&zjNk1;`+FnJI9 zrNs=XlhUW~7KA5_PL9PZYa`2R?q3j^gw1*N+G4l4gWx25<_@3YPchfH$b?M8ixyAV zU-0Svq&wbUG9d$I{0x8RmfBVUoH51$C{>@h)kscMz*`y1Y(Y5zt_RtU0D^J?JQ@U? z;XVK*@Z&>)15g5w+c>S*&R`Be3H-FeTvJpgWEDyivNoj-&-D5US%oGI8|v16LRPha z-JFnBtUV#COn@rp*D&NsM9#!6MijF8!x;=(DYBOqsjdh@&VLp9xc?mfG4*x$6*$W| zi@X*-kev;coZ_Z{Z0aD1cU4Uo1 z(y{uWn-HtrvTJ<(!0vms#x!`v1kc+EG*bDTU4F)?a9IM2De2`F2xS?_$WYiVHadB+ z;iaM{!*5~|tn?5XJ`@2SGGHYYnYFciAXfo3xyms#WkbJWv(}1P z=}_ZXvPjK2PkUkg`KGo7hYJdahyVqB>%o+qpRBC)-A0avn$Oh%70=bzPht#E$rw+; zULON@=tNRv=YJEYx`nm{YmzteTJ2RixNp!Uxs-zQ-$YtVZJSK%Ky<)#I%QkUq_Zy- zNk=tH8N$I?YxDOV959{A`;nz{Am0HMhvKm{mYo1`MuAYetHbLf5iw}B<@=1Aie!RU z@N9zD1Ho!Wm%DkPLg?yJn=88PDhQO$?jX-AH?H#9?R_hZoFQTB`BnmS7 z5WTDs)m-ApfmD+a$m~RjH*&5lp(0DN8p&k|v{Dthwn&*GR|^n|<9ga{Zks9CAT$U2 zW(qb4jbOKmPb@NYw7+O+ZMOE@L9CevAhS~*&_L|Z!{cZ3LZJvSMIOj1le%^C^aZGT zvUFHWoLCD*;C@2qB&`wL}qlt(^ z-9BUL;;4aD8@1z!bZXf*mq!20b+zU=!tqn0A^Yd2|6Bt7quhZ2)rC8zajFN#J31SM z^J#!J+Z|_5Kw}0y&RbxSipTjL%x=q-3g;!D+CW@9fw`>*RLQ@~Jq*o{ELcmCy_&;7 zYYayav||KE=5@~Z>p4cVd~bIrpw1z)nM0o$*tQOjKKuds{EG_3)Dgp)CCQ$mV9S5ZE6*bXc zXxjlT0cx@Y-$XKQsSK3zq(FTYszQH)re7j52s*T4uZ#`JEJaUlEVOOVB8?w)gI5Hg z9gEK$JF=VzYaA)y0mZ_v4gwD-4F5KE!+Iio78EH#s!e@M&3)fe%z^F$${(F-Y~t0k@CXr}7SrcpT3Z)$+sO`p99HglvL0s9p@Un$ zP$9Xyd#O$059zu@Iy%*&NJnLB7r+F6)xg)_GdB>FZQ-@m&3F-`_J9NB^mN!G3&@ws zX@pWQhMw%d(x?B)Y|VNb0~Rlw2gF&*gK>^szKM6{jc|-CGTYP`QQ~cr+Rd3{i^tsd zNF&~5=3~Iwi)fI(IU$XpoK)0q*#vLk$$^<8C=}u1CAHYsE$B7~4?D`F&O=6V8RPMI zY*UT!ikt@_880VRuaZA4%B}VZF^uE4-!@U>)|*p35UNBiI>YCqF=}#G3BW}=P31wS z&?!7c~E zCJ_Y)8=xzTT?sv%@!p05;XjFY9@J(%;gX_vf8PVS&RtvEzSvUF!bYC9lA!;9w!+Ev z#f>(F?$0akEC4F4gN*Z06i%h&n#4>7h1jCYL98kYgd4Go^LCBZcS1d zuf^MydxFC@3Agir&l$(p(_UD^^-kBIu?wJ;Zn1v36B1~pj|9H5NHgMZ;tVhe`t^R$ zt4YBIBerzBW36X}hu7R7L}Q%S-0xc5IC!*Uc+Cw`<(m8RFjBr-fQ(e(qT4w;-m^vv zvCIR`4$w-0f8Qci`gC~s4+b8m!>tEXGNL~iwO*~Opf;ha| z--Zr-T!0MK)zE5w@~=@fr>f4Ln#eO*GtjIU4R;nD-RlvpoPQtL7!~;!Y1FvM8VnHP zSj@lwHlE>ze3Ym}_EeZ@qAjfQn)G8!E*lGFAxm$}PM+2qSFyXtj z`I)Q$KpKJ&qcfO{JaX8hPb`yKT$@YF7&S6hSrl+(00ZehjQAO#5DMB%h@|y&FP@z} z@CzM{ecOK~jZjH5p5t!aLYu-+Ab&a!t(*iCtnir$m*1rY=5yUiG(pwTT5Ic87Olvz zxGmCuzDwogsa$Jq3Le_N9_GVy1R#_pg$CZ%9a$>{K?-dDJ>)9pSo2t$0>73fh`G0+ z3%Aa{j9uCPu4;;_Y#YSm_fGb`ZxKX6Mv}beIDm8+2j;Z2h=n%-$(%quc6Gm3Mq`US z3tr`1#`Z>91Bx>n&^fbP!@boWM--m}ES{7sppTG^q_`?AEvc+3(OX>yQTFxs{Hspd zu3BkZ=!wRJ3sPlP5W?dEWCBtwCJ|i{Li)KC_EvlJoX(dYmzkY_8EqZhVk~y~XMg!q zUTYgTadA>dfNrYzM;31q4(KGD_}z(VXl0o|6L>#KPyr{QGy#+S{$ntDD0E|8AB1xK z_Q>YnF{N z=|xXTO0rm+Dp}0+aG^qJ_$;+8DeB1p9jtUcMXE2bs!VQkO7RJ@IFUN6=yDLWUA|Ue z)8!e$)`Os&<{eGb?f02gkgapt(#8u#mpWl6ZTr#^+~XhV3~fp=Rpy+C3l&OJ!Vf)_g(iDT>U^%iNwBUE$s(;e@l6O{pUtY1azgs5 z^~yPOq^j+l8M6-{lkKy+$JTxppR5~r2!Kv9$L^e1xFV4z;R8s*r^?mWdW&Bj2--bd zKS7BfZqd0j3sexDh72gFGM`)IVUL+1=%g*#3yV`QoCFLYiQuILo`eHBiQtvR*^MB8 zB!br#c$grsLO_Qn1(Ii}359n@>^J1SG~_!2LLcwR0B}Y__vIGdBE|f@`?$-6D>G z7xLwJm!)IX-sYQtvnwZD)Br?M;L75LTcSoYYQ*U*YA`JrOK27!W1svi9!5!;lX+)u0Pcke3rbPgSZ{REW$xP38S5n+hgRgm5s-Grs?j zumo>x#;4MATSy5oU#0=jWINa#(dIF?u#^P5ahroq!XxO+4bbOs<0Z_}a?3(5I|eF5 z#h!INoq1EZL+@w0ym$hkxOkfJv?clKiG?*p17-$HelJ~(Xn#wn8j;gdPa#eY?q*lV z5taQukrg#{nB;`K@}9;*MMH$;=v*T5WfK6G9*?m+kO{7!04GsgSqrntQz7dws3}Ye z+uP7LTjy{4m-rLH)Ev!()Oml)!u^X4=`kIM-5vcxZKLkFbUxo!z=?3&ZxH)zRkV)@`id!vl*#d!*L68!MWbr?;A_+#8@{ zd*hh}qmHev=Q|IgdAjm$)pHB>FoD|EgOYgo!s1MV0iAe-y>l-u3>FFey9TeBKNJx# zP#-p=9CIzdl_w4%sW=RX0PS*9m`B}fYheaDXgd9FTo-=`ee2$_=$v%W z%HbiWH}NhenPx&)WON{GQe@t(T7cGgEumc37E>crey;+!_0SrZ*IW0#6)f<`+5Sd8 z6_XnBfi|VWxb@H~f*)Ezu7S|XTZLQqQB@LJljO%%l37Bl7{9FwLaS^$`A?ku1b4>z zZ}{e`d#e5*n^?!LvDHmE7mPkmTm{@O!pAc)kl5AWc_IFz;mW%gEMY}RvE%kVC zdcGYFJmAQxz|(dfQ4Y|aM>8~+qnQeA|4B5f8kcVyI#}vN&T&2*8El^gHvN*%!WSve z2?}C--^$i4t*ST$%_Tt^k&g?I(NNQ|v}TnqZPyE){r3(9-(wPE7k?iJ^PYpevXN>9 I8N{6bKXff(+W-In literal 0 HcmV?d00001 From de33c992210703192e02d52ab7fd2d13de62ce27 Mon Sep 17 00:00:00 2001 From: petjot Date: Fri, 30 Oct 2020 18:00:10 +0100 Subject: [PATCH 05/12] Introduce migration event type to the protocol --- .../ClientAddMigrationListenerCodec.java | 18 +++--- .../task/AddMigrationListenerMessageTask.java | 11 ++-- .../impl/proxy/PartitionServiceProxy.java | 8 ++- .../partition/MigrationEventHandler.java | 20 ++++--- .../partition/MigrationEventType.java | 58 +++++++++++++++++++ .../impl/MigrationListenerAdapter.java | 2 +- .../partition/impl/PartitionEventManager.java | 10 ++-- .../ClientCompatibilityNullTest_2_2.java | 4 +- .../ClientCompatibilityTest_2_2.java | 4 +- .../impl/MigrationListenerAdapterTest.java | 8 +-- 10 files changed, 103 insertions(+), 40 deletions(-) create mode 100644 hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java index 23f336abdf71a..1fdff36b1356c 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/codec/ClientAddMigrationListenerCodec.java @@ -37,7 +37,7 @@ /** * Adds a Migration listener to the cluster. */ -@Generated("45dae5149998b823955b8efceacb9dcf") +@Generated("c1de358a5eeb994a93d1c9d264dcca29") public final class ClientAddMigrationListenerCodec { //hex: 0x001100 public static final int REQUEST_MESSAGE_TYPE = 4352; @@ -47,8 +47,8 @@ public final class ClientAddMigrationListenerCodec { private static final int REQUEST_INITIAL_FRAME_SIZE = REQUEST_LOCAL_ONLY_FIELD_OFFSET + BOOLEAN_SIZE_IN_BYTES; private static final int RESPONSE_RESPONSE_FIELD_OFFSET = RESPONSE_BACKUP_ACKS_FIELD_OFFSET + BYTE_SIZE_IN_BYTES; private static final int RESPONSE_INITIAL_FRAME_SIZE = RESPONSE_RESPONSE_FIELD_OFFSET + UUID_SIZE_IN_BYTES; - private static final int EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; - private static final int EVENT_MIGRATION_INITIAL_FRAME_SIZE = EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int EVENT_MIGRATION_TYPE_FIELD_OFFSET = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; + private static final int EVENT_MIGRATION_INITIAL_FRAME_SIZE = EVENT_MIGRATION_TYPE_FIELD_OFFSET + INT_SIZE_IN_BYTES; //hex: 0x001102 private static final int EVENT_MIGRATION_MESSAGE_TYPE = 4354; private static final int EVENT_REPLICA_MIGRATION_PARTITION_ID_FIELD_OFFSET = PARTITION_ID_FIELD_OFFSET + INT_SIZE_IN_BYTES; @@ -105,13 +105,13 @@ public static java.util.UUID decodeResponse(ClientMessage clientMessage) { return decodeUUID(initialFrame.content, RESPONSE_RESPONSE_FIELD_OFFSET); } - public static ClientMessage encodeMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId) { + public static ClientMessage encodeMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int type) { ClientMessage clientMessage = ClientMessage.createForEncode(); ClientMessage.Frame initialFrame = new ClientMessage.Frame(new byte[EVENT_MIGRATION_INITIAL_FRAME_SIZE], UNFRAGMENTED_MESSAGE); initialFrame.flags |= ClientMessage.IS_EVENT_FLAG; encodeInt(initialFrame.content, TYPE_FIELD_OFFSET, EVENT_MIGRATION_MESSAGE_TYPE); encodeInt(initialFrame.content, PARTITION_ID_FIELD_OFFSET, -1); - encodeInt(initialFrame.content, EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET, partitionId); + encodeInt(initialFrame.content, EVENT_MIGRATION_TYPE_FIELD_OFFSET, type); clientMessage.add(initialFrame); MigrationStateCodec.encode(clientMessage, migrationState); @@ -142,9 +142,9 @@ public void handle(ClientMessage clientMessage) { ClientMessage.ForwardFrameIterator iterator = clientMessage.frameIterator(); if (messageType == EVENT_MIGRATION_MESSAGE_TYPE) { ClientMessage.Frame initialFrame = iterator.next(); - int partitionId = decodeInt(initialFrame.content, EVENT_MIGRATION_PARTITION_ID_FIELD_OFFSET); + int type = decodeInt(initialFrame.content, EVENT_MIGRATION_TYPE_FIELD_OFFSET); com.hazelcast.partition.MigrationState migrationState = MigrationStateCodec.decode(iterator); - handleMigrationEvent(migrationState, partitionId); + handleMigrationEvent(migrationState, type); return; } if (messageType == EVENT_REPLICA_MIGRATION_MESSAGE_TYPE) { @@ -164,9 +164,9 @@ public void handle(ClientMessage clientMessage) { /** * @param migrationState Migration state. - * @param partitionId The id assigned during the listener registration. + * @param type Type of the event. It is either MIGRATION_STARTED(0) or MIGRATION_FINISHED(1). */ - public abstract void handleMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int partitionId); + public abstract void handleMigrationEvent(com.hazelcast.partition.MigrationState migrationState, int type); /** * @param migrationState The progress information of the overall migration. diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java index 1a5a4ecbb73a2..e737249584702 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -22,6 +22,7 @@ import com.hazelcast.instance.impl.Node; import com.hazelcast.internal.nio.Connection; import com.hazelcast.internal.partition.IPartitionService; +import com.hazelcast.internal.partition.MigrationEventType; import com.hazelcast.partition.MigrationListener; import com.hazelcast.partition.MigrationState; import com.hazelcast.partition.ReplicaMigrationEvent; @@ -33,8 +34,6 @@ import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC_ORDER_KEY; -import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED; -import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED; import static com.hazelcast.spi.impl.InternalCompletableFuture.newCompletedFuture; public class AddMigrationListenerMessageTask @@ -62,12 +61,12 @@ private MigrationListener createMigrationListener() { @Override public void migrationStarted(MigrationState state) { - sendIfAlive(encodeMigrationEvent(state, MIGRATION_STARTED)); + sendIfAlive(encodeMigrationEvent(state, MigrationEventType.MIGRATION_STARTED)); } @Override public void migrationFinished(MigrationState state) { - sendIfAlive(encodeMigrationEvent(state, MIGRATION_FINISHED)); + sendIfAlive(encodeMigrationEvent(state, MigrationEventType.MIGRATION_FINISHED)); } @Override @@ -105,8 +104,8 @@ private UUID getMemberUuid(@Nullable Member source) { return source != null ? source.getUuid() : null; } - private ClientMessage encodeMigrationEvent(MigrationState migrationState, int partitionId) { - return ClientAddMigrationListenerCodec.encodeMigrationEvent(migrationState, partitionId); + private ClientMessage encodeMigrationEvent(MigrationState migrationState, MigrationEventType type) { + return ClientAddMigrationListenerCodec.encodeMigrationEvent(migrationState, type.getType()); } @Override diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java index fad5551fe0e5d..5ef2b9e35be44 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java @@ -27,6 +27,7 @@ import com.hazelcast.client.impl.spi.EventHandler; import com.hazelcast.client.impl.spi.impl.ListenerMessageCodec; import com.hazelcast.cluster.Member; +import com.hazelcast.internal.partition.MigrationEventType; import com.hazelcast.internal.partition.PartitionLostEventImpl; import com.hazelcast.internal.partition.MigrationEventHandler; import com.hazelcast.internal.partition.ReplicaMigrationEventImpl; @@ -201,8 +202,9 @@ private class ClientMigrationEventHandler extends ClientAddMigrationListenerCode } @Override - public void handleMigrationEvent(MigrationState migrationState, int partitionId) { - migrationEventHandler.handleMigrationState(migrationState, partitionId); + public void handleMigrationEvent(MigrationState migrationState, int type) { + MigrationEventType eventType = MigrationEventType.getByType(type); + migrationEventHandler.handleMigrationEvent(migrationState, eventType); } @Override @@ -220,7 +222,7 @@ public void handleReplicaMigrationEvent(MigrationState migrationState, ReplicaMigrationEvent event = new ReplicaMigrationEventImpl(migrationState, partitionId, replicaIndex, source, destination, success, elapsedTime); - migrationEventHandler.handleReplicaMigration(event); + migrationEventHandler.handleReplicaMigrationEvent(event); } private Member findMember(@Nullable UUID memberUuid) { diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java index a1f2613b47656..7171ac222ee0e 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java @@ -22,8 +22,8 @@ public final class MigrationEventHandler { - public static final int MIGRATION_STARTED = -1; - public static final int MIGRATION_FINISHED = -2; + public static final int MIGRATION_STARTED_PARTITION_ID = -1; + public static final int MIGRATION_FINISHED_PARTITION_ID = -2; private final MigrationListener migrationListener; @@ -31,8 +31,8 @@ public MigrationEventHandler(MigrationListener migrationListener) { this.migrationListener = migrationListener; } - public void handleMigrationState(MigrationState state, int partitionId) { - switch (partitionId) { + public void handleMigrationEvent(MigrationState state, MigrationEventType type) { + switch (type) { case MIGRATION_STARTED: migrationListener.migrationStarted(state); break; @@ -40,15 +40,17 @@ public void handleMigrationState(MigrationState state, int partitionId) { migrationListener.migrationFinished(state); break; default: - break; + throw new IllegalArgumentException("Invalid event type: " + type); } } - public void handleReplicaMigration(ReplicaMigrationEvent event) { + public void handleReplicaMigrationEvent(ReplicaMigrationEvent event) { switch (event.getPartitionId()) { - case MIGRATION_STARTED: - case MIGRATION_FINISHED: - handleMigrationState(event.getMigrationState(), event.getPartitionId()); + case MIGRATION_STARTED_PARTITION_ID: + handleMigrationEvent(event.getMigrationState(), MigrationEventType.MIGRATION_STARTED); + break; + case MIGRATION_FINISHED_PARTITION_ID: + handleMigrationEvent(event.getMigrationState(), MigrationEventType.MIGRATION_FINISHED); break; default: if (event.isSuccess()) { diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java new file mode 100644 index 0000000000000..807d1e1aaa09c --- /dev/null +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2008-2020, 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.internal.partition; + + +/** + * Migration event types. + * @see MigrationEventHandler + */ +public enum MigrationEventType { + + /** + * An event type indicating that the migration process started. + */ + MIGRATION_STARTED(0), + + /** + * An event type indicating that the migration process finished. + */ + MIGRATION_FINISHED(1); + + private final int type; + + MigrationEventType(final int type) { + this.type = type; + } + + /** + * @return unique ID of the event type. + */ + public int getType() { + return type; + } + + public static MigrationEventType getByType(final int type) { + if (type == MIGRATION_STARTED.type) { + return MIGRATION_STARTED; + } + if (type == MIGRATION_FINISHED.type) { + return MIGRATION_FINISHED; + } + throw new IllegalArgumentException("Invalid event type: " + type); + } +} diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java index 28b7d69563817..05b34cba961d3 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java @@ -34,7 +34,7 @@ class MigrationListenerAdapter implements PartitionEventListener Date: Mon, 2 Nov 2020 13:31:10 +0100 Subject: [PATCH 06/12] Remove MigrationEventHandler and MigrationEventType --- .../task/AddMigrationListenerMessageTask.java | 10 +-- .../impl/proxy/PartitionServiceProxy.java | 26 +++++--- .../partition/MigrationEventHandler.java | 63 ------------------- .../partition/MigrationEventType.java | 58 ----------------- .../impl/MigrationListenerAdapter.java | 23 +++++-- .../partition/impl/PartitionEventManager.java | 4 +- .../impl/MigrationListenerAdapterTest.java | 4 +- 7 files changed, 47 insertions(+), 141 deletions(-) delete mode 100644 hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java delete mode 100644 hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java index e737249584702..1abee23ab4407 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -18,11 +18,11 @@ import com.hazelcast.client.impl.protocol.ClientMessage; import com.hazelcast.client.impl.protocol.codec.ClientAddMigrationListenerCodec; +import com.hazelcast.client.impl.proxy.PartitionServiceProxy; import com.hazelcast.cluster.Member; import com.hazelcast.instance.impl.Node; import com.hazelcast.internal.nio.Connection; import com.hazelcast.internal.partition.IPartitionService; -import com.hazelcast.internal.partition.MigrationEventType; import com.hazelcast.partition.MigrationListener; import com.hazelcast.partition.MigrationState; import com.hazelcast.partition.ReplicaMigrationEvent; @@ -61,12 +61,12 @@ private MigrationListener createMigrationListener() { @Override public void migrationStarted(MigrationState state) { - sendIfAlive(encodeMigrationEvent(state, MigrationEventType.MIGRATION_STARTED)); + sendIfAlive(encodeMigrationEvent(state, PartitionServiceProxy.MIGRATION_STARTED)); } @Override public void migrationFinished(MigrationState state) { - sendIfAlive(encodeMigrationEvent(state, MigrationEventType.MIGRATION_FINISHED)); + sendIfAlive(encodeMigrationEvent(state, PartitionServiceProxy.MIGRATION_FINISHED)); } @Override @@ -104,8 +104,8 @@ private UUID getMemberUuid(@Nullable Member source) { return source != null ? source.getUuid() : null; } - private ClientMessage encodeMigrationEvent(MigrationState migrationState, MigrationEventType type) { - return ClientAddMigrationListenerCodec.encodeMigrationEvent(migrationState, type.getType()); + private ClientMessage encodeMigrationEvent(MigrationState migrationState, int type) { + return ClientAddMigrationListenerCodec.encodeMigrationEvent(migrationState, type); } @Override diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java index 5ef2b9e35be44..552295f0d494d 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java @@ -27,9 +27,7 @@ import com.hazelcast.client.impl.spi.EventHandler; import com.hazelcast.client.impl.spi.impl.ListenerMessageCodec; import com.hazelcast.cluster.Member; -import com.hazelcast.internal.partition.MigrationEventType; import com.hazelcast.internal.partition.PartitionLostEventImpl; -import com.hazelcast.internal.partition.MigrationEventHandler; import com.hazelcast.internal.partition.ReplicaMigrationEventImpl; import com.hazelcast.partition.MigrationListener; import com.hazelcast.partition.MigrationState; @@ -52,6 +50,9 @@ */ public final class PartitionServiceProxy implements PartitionService { + public static final int MIGRATION_STARTED = 0; + public static final int MIGRATION_FINISHED = 1; + private final ClientPartitionService partitionService; private final ClientListenerService listenerService; private final ClientClusterService clusterService; @@ -195,16 +196,23 @@ public void handlePartitionLostEvent(int partitionId, int lostBackupCount, UUID private class ClientMigrationEventHandler extends ClientAddMigrationListenerCodec.AbstractEventHandler implements EventHandler { - private final MigrationEventHandler migrationEventHandler; + private final MigrationListener listener; ClientMigrationEventHandler(MigrationListener listener) { - this.migrationEventHandler = new MigrationEventHandler(listener); + this.listener = listener; } @Override public void handleMigrationEvent(MigrationState migrationState, int type) { - MigrationEventType eventType = MigrationEventType.getByType(type); - migrationEventHandler.handleMigrationEvent(migrationState, eventType); + switch (type) { + case MIGRATION_STARTED: + listener.migrationStarted(migrationState); + break; + case MIGRATION_FINISHED: + listener.migrationFinished(migrationState); + break; + default: + } } @Override @@ -222,7 +230,11 @@ public void handleReplicaMigrationEvent(MigrationState migrationState, ReplicaMigrationEvent event = new ReplicaMigrationEventImpl(migrationState, partitionId, replicaIndex, source, destination, success, elapsedTime); - migrationEventHandler.handleReplicaMigrationEvent(event); + if (event.isSuccess()) { + listener.replicaMigrationCompleted(event); + } else { + listener.replicaMigrationFailed(event); + } } private Member findMember(@Nullable UUID memberUuid) { diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java deleted file mode 100644 index 7171ac222ee0e..0000000000000 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventHandler.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (c) 2008-2020, 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.internal.partition; - -import com.hazelcast.partition.MigrationListener; -import com.hazelcast.partition.MigrationState; -import com.hazelcast.partition.ReplicaMigrationEvent; - -public final class MigrationEventHandler { - - public static final int MIGRATION_STARTED_PARTITION_ID = -1; - public static final int MIGRATION_FINISHED_PARTITION_ID = -2; - - private final MigrationListener migrationListener; - - public MigrationEventHandler(MigrationListener migrationListener) { - this.migrationListener = migrationListener; - } - - public void handleMigrationEvent(MigrationState state, MigrationEventType type) { - switch (type) { - case MIGRATION_STARTED: - migrationListener.migrationStarted(state); - break; - case MIGRATION_FINISHED: - migrationListener.migrationFinished(state); - break; - default: - throw new IllegalArgumentException("Invalid event type: " + type); - } - } - - public void handleReplicaMigrationEvent(ReplicaMigrationEvent event) { - switch (event.getPartitionId()) { - case MIGRATION_STARTED_PARTITION_ID: - handleMigrationEvent(event.getMigrationState(), MigrationEventType.MIGRATION_STARTED); - break; - case MIGRATION_FINISHED_PARTITION_ID: - handleMigrationEvent(event.getMigrationState(), MigrationEventType.MIGRATION_FINISHED); - break; - default: - if (event.isSuccess()) { - migrationListener.replicaMigrationCompleted(event); - } else { - migrationListener.replicaMigrationFailed(event); - } - } - } -} diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java deleted file mode 100644 index 807d1e1aaa09c..0000000000000 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/MigrationEventType.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (c) 2008-2020, 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.internal.partition; - - -/** - * Migration event types. - * @see MigrationEventHandler - */ -public enum MigrationEventType { - - /** - * An event type indicating that the migration process started. - */ - MIGRATION_STARTED(0), - - /** - * An event type indicating that the migration process finished. - */ - MIGRATION_FINISHED(1); - - private final int type; - - MigrationEventType(final int type) { - this.type = type; - } - - /** - * @return unique ID of the event type. - */ - public int getType() { - return type; - } - - public static MigrationEventType getByType(final int type) { - if (type == MIGRATION_STARTED.type) { - return MIGRATION_STARTED; - } - if (type == MIGRATION_FINISHED.type) { - return MIGRATION_FINISHED; - } - throw new IllegalArgumentException("Invalid event type: " + type); - } -} diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java index 05b34cba961d3..6831c5713935b 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapter.java @@ -17,7 +17,6 @@ package com.hazelcast.internal.partition.impl; import com.hazelcast.internal.partition.PartitionEventListener; -import com.hazelcast.internal.partition.MigrationEventHandler; import com.hazelcast.partition.ReplicaMigrationEvent; import com.hazelcast.partition.MigrationListener; @@ -26,15 +25,31 @@ */ class MigrationListenerAdapter implements PartitionEventListener { - private final MigrationEventHandler migrationEventHandler; + static final int MIGRATION_STARTED_PARTITION_ID = -1; + static final int MIGRATION_FINISHED_PARTITION_ID = -2; + + private final MigrationListener migrationListener; MigrationListenerAdapter(MigrationListener migrationListener) { - this.migrationEventHandler = new MigrationEventHandler(migrationListener); + this.migrationListener = migrationListener; } @Override public void onEvent(ReplicaMigrationEvent event) { - migrationEventHandler.handleReplicaMigrationEvent(event); + switch (event.getPartitionId()) { + case MIGRATION_STARTED_PARTITION_ID: + migrationListener.migrationStarted(event.getMigrationState()); + break; + case MIGRATION_FINISHED_PARTITION_ID: + migrationListener.migrationFinished(event.getMigrationState()); + break; + default: + if (event.isSuccess()) { + migrationListener.replicaMigrationCompleted(event); + } else { + migrationListener.replicaMigrationFailed(event); + } + } } } diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java index 69fdd49713de9..ac261e04471ff 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java @@ -46,8 +46,8 @@ import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC_ORDER_KEY; import static com.hazelcast.internal.partition.InternalPartitionService.PARTITION_LOST_EVENT_TOPIC; -import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED_PARTITION_ID; -import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED_PARTITION_ID; +import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_FINISHED_PARTITION_ID; +import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_STARTED_PARTITION_ID; import static com.hazelcast.internal.util.ConcurrencyUtil.CALLER_RUNS; import static com.hazelcast.internal.util.Preconditions.checkNotNull; import static com.hazelcast.spi.impl.executionservice.ExecutionService.SYSTEM_EXECUTOR; diff --git a/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java b/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java index 82aa695c8b633..8334603bcfe07 100644 --- a/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java +++ b/hazelcast/src/test/java/com/hazelcast/internal/partition/impl/MigrationListenerAdapterTest.java @@ -30,8 +30,8 @@ import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; -import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_FINISHED_PARTITION_ID; -import static com.hazelcast.internal.partition.MigrationEventHandler.MIGRATION_STARTED_PARTITION_ID; +import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_FINISHED_PARTITION_ID; +import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_STARTED_PARTITION_ID; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; From 103713afa902578c349e669802e34ee504664ca6 Mon Sep 17 00:00:00 2001 From: petjot Date: Thu, 5 Nov 2020 23:15:46 +0100 Subject: [PATCH 07/12] Send client message with key = null --- .../impl/protocol/task/AddMigrationListenerMessageTask.java | 3 +-- .../hazelcast/client/impl/proxy/PartitionServiceProxy.java | 5 +++-- .../internal/partition/InternalPartitionService.java | 1 - .../internal/partition/impl/PartitionEventManager.java | 3 +-- 4 files changed, 5 insertions(+), 7 deletions(-) diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java index 1abee23ab4407..8ab81a9f8227d 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -33,7 +33,6 @@ import java.util.concurrent.CompletableFuture; import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; -import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC_ORDER_KEY; import static com.hazelcast.spi.impl.InternalCompletableFuture.newCompletedFuture; public class AddMigrationListenerMessageTask @@ -83,7 +82,7 @@ public void replicaMigrationFailed(ReplicaMigrationEvent event) { private void sendIfAlive(ClientMessage eventMessage) { if (endpoint.isAlive()) { - sendClientMessage(MIGRATION_EVENT_TOPIC_ORDER_KEY, eventMessage); + sendClientMessage(null, eventMessage); } } diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java index 552295f0d494d..fd866d622297d 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/proxy/PartitionServiceProxy.java @@ -91,7 +91,7 @@ public UUID addMigrationListener(@Nonnull MigrationListener migrationListener) { } @Override - public boolean removeMigrationListener(UUID registrationId) { + public boolean removeMigrationListener(@Nonnull UUID registrationId) { checkNotNull(registrationId, "registrationId can't be null"); return listenerService.deregisterListener(registrationId); } @@ -104,7 +104,7 @@ public UUID addPartitionLostListener(@Nonnull PartitionLostListener partitionLos } @Override - public boolean removePartitionLostListener(UUID registrationId) { + public boolean removePartitionLostListener(@Nonnull UUID registrationId) { checkNotNull(registrationId, "registrationId can't be null"); return listenerService.deregisterListener(registrationId); } @@ -212,6 +212,7 @@ public void handleMigrationEvent(MigrationState migrationState, int type) { listener.migrationFinished(migrationState); break; default: + // left empty for future type extensions instead of throwing an exception } } diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java index a7adc0932c89a..b72f1a58c22bc 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/InternalPartitionService.java @@ -35,7 +35,6 @@ public interface InternalPartitionService extends IPartitionService, ManagedServ * Static constant for dispatching and listening migration events */ String MIGRATION_EVENT_TOPIC = ".migration"; - int MIGRATION_EVENT_TOPIC_ORDER_KEY = MIGRATION_EVENT_TOPIC.hashCode(); /** * Static constant for dispatching and listening internal partition lost events diff --git a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java index ac261e04471ff..a72eac0ab91bb 100644 --- a/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java +++ b/hazelcast/src/main/java/com/hazelcast/internal/partition/impl/PartitionEventManager.java @@ -44,7 +44,6 @@ import static com.hazelcast.internal.partition.IPartitionService.SERVICE_NAME; import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC; -import static com.hazelcast.internal.partition.InternalPartitionService.MIGRATION_EVENT_TOPIC_ORDER_KEY; import static com.hazelcast.internal.partition.InternalPartitionService.PARTITION_LOST_EVENT_TOPIC; import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_FINISHED_PARTITION_ID; import static com.hazelcast.internal.partition.impl.MigrationListenerAdapter.MIGRATION_STARTED_PARTITION_ID; @@ -97,7 +96,7 @@ public void sendMigrationProcessCompletedEvent(MigrationState state) { private void sendMigrationEvent(ReplicaMigrationEvent event) { EventService eventService = nodeEngine.getEventService(); // All migration events are sent in order. - eventService.publishEvent(SERVICE_NAME, MIGRATION_EVENT_TOPIC, event, MIGRATION_EVENT_TOPIC_ORDER_KEY); + eventService.publishEvent(SERVICE_NAME, MIGRATION_EVENT_TOPIC, event, MIGRATION_EVENT_TOPIC.hashCode()); } public UUID addMigrationListener(@Nonnull MigrationListener listener) { From 578c6dfd25d2338dbaf01a564c84ae96102442fc Mon Sep 17 00:00:00 2001 From: petjot Date: Thu, 5 Nov 2020 23:49:53 +0100 Subject: [PATCH 08/12] Use IPartitionService instead of InternalPartitionService --- .../impl/protocol/task/RemoveMigrationListenerMessageTask.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java index c9ac491a2ce79..53ba0c20a1146 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java @@ -20,6 +20,7 @@ import com.hazelcast.client.impl.protocol.codec.ClientRemoveMigrationListenerCodec; import com.hazelcast.instance.impl.Node; import com.hazelcast.internal.nio.Connection; +import com.hazelcast.internal.partition.IPartitionService; import com.hazelcast.internal.partition.InternalPartitionService; import java.security.Permission; @@ -35,7 +36,7 @@ public RemoveMigrationListenerMessageTask(ClientMessage clientMessage, Node node @Override protected Future deRegisterListener() { - InternalPartitionService service = getService(InternalPartitionService.SERVICE_NAME); + IPartitionService service = getService(IPartitionService.SERVICE_NAME); return service.removeMigrationListenerAsync(parameters); } From 912e4e51b22d47b603930b1ef0146cb6273020ef Mon Sep 17 00:00:00 2001 From: petjot Date: Thu, 5 Nov 2020 23:52:12 +0100 Subject: [PATCH 09/12] Use IPartitionService instead of InternalPartitionService --- .../impl/protocol/task/RemoveMigrationListenerMessageTask.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java index 53ba0c20a1146..5bb3d7b626640 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java @@ -57,7 +57,7 @@ protected ClientMessage encodeResponse(Object response) { @Override public String getServiceName() { - return InternalPartitionService.SERVICE_NAME; + return IPartitionService.SERVICE_NAME; } @Override From cd91e2bc440a86a1f1a63660225851af8615943c Mon Sep 17 00:00:00 2001 From: petjot Date: Fri, 6 Nov 2020 13:36:20 +0100 Subject: [PATCH 10/12] Send client message with key = MIGRATION_EVENT_TOPIC hash code and add a test --- .../task/AddMigrationListenerMessageTask.java | 2 +- .../RemoveMigrationListenerMessageTask.java | 1 - .../ClientMigrationListenerTest.java | 63 +++++++++++++++++-- 3 files changed, 58 insertions(+), 8 deletions(-) diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java index 8ab81a9f8227d..b59092b1a3e18 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -82,7 +82,7 @@ public void replicaMigrationFailed(ReplicaMigrationEvent event) { private void sendIfAlive(ClientMessage eventMessage) { if (endpoint.isAlive()) { - sendClientMessage(null, eventMessage); + sendClientMessage(MIGRATION_EVENT_TOPIC.hashCode(), eventMessage); } } diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java index 5bb3d7b626640..dba10e4f56453 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/RemoveMigrationListenerMessageTask.java @@ -21,7 +21,6 @@ import com.hazelcast.instance.impl.Node; import com.hazelcast.internal.nio.Connection; import com.hazelcast.internal.partition.IPartitionService; -import com.hazelcast.internal.partition.InternalPartitionService; import java.security.Permission; import java.util.UUID; diff --git a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java index 600cc223024d8..c85992f7dbfb4 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java +++ b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java @@ -24,6 +24,7 @@ import com.hazelcast.internal.partition.MigrationStateImpl; import com.hazelcast.internal.util.UuidUtil; import com.hazelcast.partition.MigrationListener; +import com.hazelcast.partition.MigrationState; import com.hazelcast.partition.PartitionMigrationListenerTest; import com.hazelcast.partition.PartitionService; import com.hazelcast.partition.ReplicaMigrationEvent; @@ -39,6 +40,7 @@ import java.util.Collection; import java.util.UUID; +import java.util.function.Consumer; import java.util.function.Function; import static com.hazelcast.internal.cluster.impl.AdvancedClusterStateTest.changeClusterStateEventually; @@ -54,6 +56,8 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; @@ -147,30 +151,41 @@ public void testRemoveMigrationListener_whenExistingRegistrationId() { @Test public void testMigrationListenerInvoked_whenRegisteredByConfig() { PartitionMigrationListenerTest.EventCollectingMigrationListener clientListener = eventCollectingMigrationListener(); - Function clientSupplier = listener -> { ClientConfig clientConfig = new ClientConfig().addListenerConfig(new ListenerConfig(listener)); return hazelcastFactory.newHazelcastClient(clientConfig); }; - testMigrationListenerInvoked(clientListener, clientSupplier); + testMigrationListenerInvoked(clientListener, clientSupplier, this::assertMigrationProcess); } @Test public void testMigrationListenerInvoked_whenRegisteredByPartitionService() { PartitionMigrationListenerTest.EventCollectingMigrationListener clientListener = eventCollectingMigrationListener(); + Function clientSupplier = listener -> { + HazelcastInstance client = hazelcastFactory.newHazelcastClient(); + client.getPartitionService().addMigrationListener(listener); + return client; + }; + + testMigrationListenerInvoked(clientListener, clientSupplier, this::assertMigrationProcess); + } + @Test + public void testAllMigrationListenerMethodsInvokedOnTheSameThread() { + SingleThreadMigrationListener clientListener = new SingleThreadMigrationListener(); Function clientSupplier = listener -> { HazelcastInstance client = hazelcastFactory.newHazelcastClient(); client.getPartitionService().addMigrationListener(listener); return client; }; - testMigrationListenerInvoked(clientListener, clientSupplier); + testMigrationListenerInvoked(clientListener, clientSupplier, SingleThreadMigrationListener::assertAllMethodsInvokedOnTheSameThread); } - private void testMigrationListenerInvoked(PartitionMigrationListenerTest.EventCollectingMigrationListener clientListener, - Function clientFactory) { + private void testMigrationListenerInvoked(T clientListener, + Function clientFactory, + Consumer assertFunction) { HazelcastInstance instance1 = hazelcastFactory.newHazelcastInstance(); HazelcastInstance client = clientFactory.apply(clientListener); @@ -186,7 +201,7 @@ private void testMigrationListenerInvoked(PartitionMigrationListenerTest.EventCo waitAllForSafeState(instance2, instance1, client); assertRegistrationsSizeEventually(instance1, 1); - assertMigrationProcess(clientListener); + assertFunction.accept(clientListener); } private void verifyMigrationListenerNeverInvoked(MigrationListener listener) { @@ -215,4 +230,40 @@ private void assertRegistrationsSizeEventually(HazelcastInstance instance, int s assertEquals(size, registrations.size()); }); } + + static class SingleThreadMigrationListener implements MigrationListener { + + private String threadName; + private boolean finished = false; + + @Override + public void migrationStarted(MigrationState state) { + assertNull(threadName); + threadName = Thread.currentThread().getName(); + } + + @Override + public void migrationFinished(MigrationState state) { + assertNotNull(threadName); + assertEquals(threadName, Thread.currentThread().getName()); + finished = true; + } + + @Override + public void replicaMigrationCompleted(ReplicaMigrationEvent event) { + assertNotNull(threadName); + assertEquals(threadName, Thread.currentThread().getName()); + + } + + @Override + public void replicaMigrationFailed(ReplicaMigrationEvent event) { + assertNotNull(threadName); + assertEquals(threadName, Thread.currentThread().getName()); + } + + public void assertAllMethodsInvokedOnTheSameThread() { + assertTrueEventually(() -> assertTrue(finished)); + } + }; } From 032c8a972565a6b9fa7de69900508c902a68a854 Mon Sep 17 00:00:00 2001 From: petjot Date: Fri, 6 Nov 2020 16:02:39 +0100 Subject: [PATCH 11/12] Test migration listener invoked on a single thread --- .../task/AddMigrationListenerMessageTask.java | 1 + .../ClientMigrationListenerTest.java | 43 +++++++++++-------- 2 files changed, 27 insertions(+), 17 deletions(-) diff --git a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java index b59092b1a3e18..723567b483193 100644 --- a/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java +++ b/hazelcast/src/main/java/com/hazelcast/client/impl/protocol/task/AddMigrationListenerMessageTask.java @@ -82,6 +82,7 @@ public void replicaMigrationFailed(ReplicaMigrationEvent event) { private void sendIfAlive(ClientMessage eventMessage) { if (endpoint.isAlive()) { + // use a constant "key" to enforce migration event handling order sendClientMessage(MIGRATION_EVENT_TOPIC.hashCode(), eventMessage); } } diff --git a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java index c85992f7dbfb4..1f3d9c4aa7a2c 100644 --- a/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java +++ b/hazelcast/src/test/java/com/hazelcast/client/partitionservice/ClientMigrationListenerTest.java @@ -56,8 +56,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; @@ -180,12 +178,14 @@ public void testAllMigrationListenerMethodsInvokedOnTheSameThread() { return client; }; - testMigrationListenerInvoked(clientListener, clientSupplier, SingleThreadMigrationListener::assertAllMethodsInvokedOnTheSameThread); + testMigrationListenerInvoked(clientListener, clientSupplier, + SingleThreadMigrationListener::assertAllMethodsInvokedOnTheSameThread); } - private void testMigrationListenerInvoked(T clientListener, - Function clientFactory, - Consumer assertFunction) { + private void testMigrationListenerInvoked( + T clientListener, + Function clientFactory, + Consumer assertFunction) { HazelcastInstance instance1 = hazelcastFactory.newHazelcastInstance(); HazelcastInstance client = clientFactory.apply(clientListener); @@ -234,36 +234,45 @@ private void assertRegistrationsSizeEventually(HazelcastInstance instance, int s static class SingleThreadMigrationListener implements MigrationListener { private String threadName; - private boolean finished = false; + private volatile boolean finished = false; + private volatile boolean invokedOnSingleThread = true; @Override public void migrationStarted(MigrationState state) { - assertNull(threadName); threadName = Thread.currentThread().getName(); } @Override public void migrationFinished(MigrationState state) { - assertNotNull(threadName); - assertEquals(threadName, Thread.currentThread().getName()); + if (isInvokedFromAnotherThread()) { + invokedOnSingleThread = false; + } finished = true; } @Override public void replicaMigrationCompleted(ReplicaMigrationEvent event) { - assertNotNull(threadName); - assertEquals(threadName, Thread.currentThread().getName()); - + if (isInvokedFromAnotherThread()) { + invokedOnSingleThread = false; + } } @Override public void replicaMigrationFailed(ReplicaMigrationEvent event) { - assertNotNull(threadName); - assertEquals(threadName, Thread.currentThread().getName()); + if (isInvokedFromAnotherThread()) { + invokedOnSingleThread = false; + } } public void assertAllMethodsInvokedOnTheSameThread() { - assertTrueEventually(() -> assertTrue(finished)); + assertTrueEventually(() -> { + assertTrue(finished); + assertTrue(invokedOnSingleThread); + }); + } + + private boolean isInvokedFromAnotherThread() { + return !Thread.currentThread().getName().equals(threadName); } - }; + } } From 9ced3ebb9e12a222b10d95a494c9ea5db76e9c9c Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 3 Oct 2021 18:24:00 +0000 Subject: [PATCH 12/12] Bump jline.version from 3.19.0 to 3.20.0 Bumps `jline.version` from 3.19.0 to 3.20.0. Updates `jline` from 3.19.0 to 3.20.0 - [Release notes](https://github.com/jline/jline3/releases) - [Changelog](https://github.com/jline/jline3/blob/master/changelog.md) - [Commits](https://github.com/jline/jline3/compare/jline-parent-3.19.0...jline-parent-3.20.0) Updates `jline-terminal` from 3.19.0 to 3.20.0 - [Release notes](https://github.com/jline/jline3/releases) - [Changelog](https://github.com/jline/jline3/blob/master/changelog.md) - [Commits](https://github.com/jline/jline3/compare/jline-parent-3.19.0...jline-parent-3.20.0) Updates `jline-reader` from 3.19.0 to 3.20.0 - [Release notes](https://github.com/jline/jline3/releases) - [Changelog](https://github.com/jline/jline3/blob/master/changelog.md) - [Commits](https://github.com/jline/jline3/compare/jline-parent-3.19.0...jline-parent-3.20.0) Updates `jline-terminal-jansi` from 3.19.0 to 3.20.0 - [Release notes](https://github.com/jline/jline3/releases) - [Changelog](https://github.com/jline/jline3/blob/master/changelog.md) - [Commits](https://github.com/jline/jline3/compare/jline-parent-3.19.0...jline-parent-3.20.0) --- updated-dependencies: - dependency-name: org.jline:jline dependency-type: direct:production update-type: version-update:semver-minor - dependency-name: org.jline:jline-terminal dependency-type: direct:production update-type: version-update:semver-minor - dependency-name: org.jline:jline-reader dependency-type: direct:production update-type: version-update:semver-minor - dependency-name: org.jline:jline-terminal-jansi dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] --- pom.xml | 934 ++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 705 insertions(+), 229 deletions(-) diff --git a/pom.xml b/pom.xml index f6e5520d9f929..7e9815d3fb64b 100644 --- a/pom.xml +++ b/pom.xml @@ -1,5 +1,5 @@ + 3.12.12 - 2.13.3 - 1.7.30 + + + 1.10.2 + 1.11.976 + 4.8.66 + 1.34.0 + 30.1.1-jre + 3.3.1 + 2.12.1 + 3.20.0 + 2.0.1 + 1.1.1 + 1.2 + 2.2.2 + 1.3.61 + 1.2.17 + 2.13.2 + 2.14.0 + 8.0.20 + 4.1.63.Final + 4.2.0 + 1.12.0 + 3.9.0 + 0.14.0 + 3.13.0 + 2.12 + 1.7.30 + 4.3.0.RELEASE + 1.26 + 2.1 - 2.11.2 - 4.13.1 + + 2.11.0 + 5.15.11 + 3.15.0 + 3.9.3 + 1.10.21 + 1.15 + 2.7 + 3.11 + 1.11.6 + 3.0.1u2 1.3 + 4.3.6 + 1.27 + 1.1.1 + 4.13.2 3.6.0 - 2.0.7 - 1.10.9 + 2.0.9 0.9.10 - 1.21 - 3.4 - 1.10.0 - 3.0.1u2 - 4.3.6 + 1.15.3 + 3.5.8 + 0.21.0 ${basedir}/lib/jacocoagent.jar @@ -108,18 +151,8 @@ java true - 8.29 - true - 1.1.1 - 1.1.1 - - 2.1 - - 1.3.160 - 3.9.3 - com.hazelcast @@ -128,6 +161,15 @@ -Xms512m -Xmx2G + + + 8.38 + ${main.basedir}/checkstyle/checkstyle.xml + ${main.basedir}/checkstyle/suppressions.xml + ${main.basedir}/checkstyle/ClassHeader.txt + + package + jar-with-dependencies @@ -185,10 +227,12 @@ **/*.html **/*.bat **/*.sh + **/*.py **/*.properties **/*.xml **/*.yaml **/*.xsd + **/hazelcast-config-*.json **/*.handlers **/*.schemas @@ -206,25 +250,60 @@ + + + + src/test/resources + + com/hazelcast/jet/server/testjob/** + + + + org.apache.maven.plugins - maven-compiler-plugin - ${maven.compiler.plugin.version} + maven-checkstyle-plugin + ${maven.checkstyle.plugin.version} + + + validate + + checkstyle + + + - ${jdk.version} - ${jdk.version} - ${project.build.sourceEncoding} + ${checkstyle.configLocation} + ${checkstyle.supressionsLocation} + ${checkstyle.headerLocation} + false + false + true + true + true + true + true + main.basedir=${main.basedir} + **/module-info.java + + + com.puppycrawl.tools + checkstyle + ${checkstyle.version} + + - com.github.spotbugs - spotbugs-maven-plugin - ${maven.spotbugs.plugin.version} + org.apache.maven.plugins + maven-compiler-plugin + ${maven.compiler.plugin.version} - true - true + ${jdk.version} + ${jdk.version} + ${project.build.sourceEncoding} @@ -245,7 +324,6 @@ org.apache.maven.plugins maven-surefire-plugin - ${maven.surefire.plugin.version} false false @@ -273,12 +351,7 @@ **/jsr/**.java **/**IT.java - com.hazelcast.sql.SqlIntegrationTestSuite.java - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.SlowTest, com.hazelcast.test.annotation.NightlyTest @@ -291,6 +364,7 @@ maven-failsafe-plugin ${maven.failsafe.plugin.version} + false ${vmHeapSettings} ${javaModuleArgs} @@ -302,10 +376,6 @@ false true - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.SlowTest, com.hazelcast.test.annotation.NightlyTest @@ -340,7 +410,148 @@ + + maven-resources-plugin + + + add-notice-and-license + none + + copy-resources + + + ${project.build.outputDirectory}/META-INF + + + .. + + NOTICE + + + + + ../hazelcast-build-utils/src/main/resources + + LICENSE + + + + + + + + + org.codehaus.mojo + license-maven-plugin + + + add-third-party + + add-third-party + + generate-resources + + ${project.build.outputDirectory}/META-INF + true + true + ${main.basedir}/hazelcast-build-utils/src/main/resources/hazelcast-thirdparty-template.ftl + + CC0 + Apache License, Version 2.0 + MIT License + Public Domain + EPL 2.0 + BSD 3-Clause License + BSD 2-Clause License + The JSON License + + + + Apache License, Version 2.0|Apache License v2.0| + Apache Software License 2.0|The Apache Software License, Version 2.0| + Apache License, version 2.0|The Apache Software License, version 2.0| + Apache 2|Apache 2.0|Apache-2.0|Apache License 2.0|The Apache License, Version 2.0| + Apache Software License - Version 2.0|Apache License Version 2.0 + + MIT License|MIT|The MIT License|MIT license|The MIT License (MIT) + + BSD 3-Clause License|BSD License|BSD|BSD licence|The BSD License|3-Clause BSD License| + New BSD License|New BSD license|The New BSD License|Revised BSD|BSD New license| + BSD-3-Clause + + BSD 2-Clause License|BSD-2-Clause|BSD 2-Clause license + CC0|Public Domain, per Creative Commons CC0 + + CDDL|CDDL + GPLv2 with classpath exception|CDDL License|CDDL/GPLv2+CE + + + Eclipse Distribution License - v 1.0|EDL 1.0 + + + + + + + com.hazelcast + test,provided + + + + org.owasp + dependency-check-maven + ${owasp.dependency-check.version} + + ALL + true + false + 10 + owasp-check-suppressions.xml + + + + + + org.apache.maven.plugins + maven-shade-plugin + ${maven.shade.plugin.version} + + + + *:* + + module-info.class + META-INF/*.SF + META-INF/*.DSA + META-INF/*.RSA + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + ${maven.surefire.plugin.version} + + + org.apache.maven.plugins + maven-jar-plugin + ${maven.jar.plugin.version} + + + org.apache.maven.plugins + maven-resources-plugin + ${maven.resources.plugin.version} + + + org.codehaus.mojo + license-maven-plugin + ${codehause.license.plugin.version} + + + @@ -349,31 +560,6 @@ parallelTest - - org.jacoco - jacoco-maven-plugin - ${maven.jacoco.plugin.version} - - false - true - jacocoArgLine - - - - prepare-unit-tests - - prepare-agent - - - - jacoco-site - verify - - report - - - - org.apache.maven.plugins maven-surefire-plugin @@ -388,7 +574,7 @@ false false - + 0.5C true @@ -402,7 +588,6 @@ -Dlog4j.configurationFile=log4j2.xml -Dlog4j.skipJansi=true ${extraVmArgs} - ${jacocoArgLine} **/**.java @@ -410,10 +595,8 @@ **/jsr/**.java **/**IT.java - com.hazelcast.sql.SqlIntegrationTestSuite.java - com.hazelcast.test.annotation.QuickTest AND com.hazelcast.test.annotation.ParallelJVMTest @@ -433,6 +616,7 @@ false + false ${vmHeapSettings} ${javaModuleArgs} @@ -442,7 +626,6 @@ -Dlog4j.configurationFile=log4j2.xml -Dlog4j.skipJansi=true ${extraVmArgs} - ${jacocoArgLine} **/**.java @@ -450,12 +633,7 @@ **/jsr/**.java **/**IT.java - com.hazelcast.sql.SqlIntegrationTestSuite.java - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.SlowTest, com.hazelcast.test.annotation.NightlyTest, @@ -465,10 +643,53 @@ + + org.apache.maven.plugins + maven-failsafe-plugin + ${maven.failsafe.plugin.version} + + false + false + + ${vmHeapSettings} + ${javaModuleArgs} + -Dhazelcast.phone.home.enabled=false + -Dhazelcast.logging.type=none + -Dhazelcast.test.use.network=false + -Dlog4j.configurationFile=log4j2.xml + -Dlog4j.skipJansi=true + ${extraVmArgs} + + false + true + + com.hazelcast.test.annotation.SlowTest, + com.hazelcast.test.annotation.NightlyTest + + + + + + integration-test + verify + + + + + + pr-builder + + true + + + none + + + LOCAL @@ -497,12 +718,7 @@ **/jsr/**.java **/**IT.java - com.hazelcast.sql.SqlIntegrationTestSuite.java - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.SlowTest, com.hazelcast.test.annotation.NightlyTest @@ -516,6 +732,7 @@ ${maven.failsafe.plugin.version} false + false ${vmHeapSettings} ${javaModuleArgs} @@ -526,10 +743,6 @@ false true - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.SlowTest, com.hazelcast.test.annotation.NightlyTest @@ -670,13 +883,7 @@ **/**IT.java - com.hazelcast.sql.SqlIntegrationTestSuite.java - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.annotation.SlowTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.NightlyTest @@ -688,6 +895,7 @@ maven-failsafe-plugin ${maven.failsafe.plugin.version} + false ${vmHeapSettings} ${javaModuleArgs} @@ -697,11 +905,6 @@ -Dlog4j.skipJansi=true ${extraVmArgs} - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.annotation.SlowTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.NightlyTest @@ -756,7 +959,7 @@ 1024 ${maven.javadoc.plugin.excludePackageNames} - none + -missing @@ -771,7 +974,7 @@ org.sonatype.plugins nexus-staging-maven-plugin - 1.6.3 + 1.6.8 true release-repository @@ -781,9 +984,6 @@ - - hazelcast-all - @@ -792,9 +992,6 @@ true - - hazelcast-all - @@ -803,7 +1000,7 @@ ${maven.javadoc.plugin.version} ${maven.javadoc.plugin.excludePackageNames} - none + -missing @@ -818,78 +1015,6 @@ - - zip - - hazelcast-all - - - - - checkstyle - - - - org.apache.maven.plugins - maven-checkstyle-plugin - ${maven.checkstyle.plugin.version} - - - validate - - checkstyle - - - - - ${main.basedir}/checkstyle/checkstyle.xml - ${main.basedir}/checkstyle/suppressions.xml - ${main.basedir}/checkstyle/ClassHeader.txt - false - true - true - true - true - true - true - main.basedir=${main.basedir} - - - - com.puppycrawl.tools - checkstyle - ${checkstyle.version} - - - - - - - - - spotbugs - - - - com.github.spotbugs - spotbugs-maven-plugin - ${maven.spotbugs.plugin.version} - - - compile - - check - - - - - true - - - - - - nightly-build @@ -917,7 +1042,6 @@ **/**IT.java **/jsr/**.java - com.hazelcast.sql.SqlIntegrationTestSuite.java com.hazelcast.test.annotation.NightlyTest, @@ -930,6 +1054,7 @@ maven-failsafe-plugin ${maven.failsafe.plugin.version} + false ${vmHeapSettings} ${javaModuleArgs} @@ -986,14 +1111,7 @@ **/jsr/**.java **/**IT.java - com.hazelcast.sql.SqlIntegrationTestSuite.java - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.annotation.SlowTest, - com.hazelcast.test.modulepath.ModulePathTest, - com.hazelcast.test.annotation.NightlyTest - @@ -1001,6 +1119,7 @@ maven-failsafe-plugin ${maven.failsafe.plugin.version} + false ${vmHeapSettings} ${javaModuleArgs} @@ -1012,12 +1131,6 @@ false true - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.annotation.SlowTest, - com.hazelcast.test.modulepath.ModulePathTest, - com.hazelcast.test.annotation.NightlyTest - @@ -1110,12 +1223,7 @@ **/UserCodeDeploymentSmokeTest.java **/OperationRunnerImplTest.java **/**IT.java - com.hazelcast.sql.SqlIntegrationTestSuite.java - - com.hazelcast.test.annotation.QuickTest, - com.hazelcast.test.modulepath.ModulePathTest - com.hazelcast.test.annotation.SlowTest, com.hazelcast.test.annotation.NightlyTest, @@ -1126,6 +1234,33 @@ + + + not-quick + + + !quick + + + + extensions + distribution + + + + quick + + + quick + + + + true + true + true + true + + @@ -1155,6 +1290,349 @@ + + + + + + + com.fasterxml.jackson + jackson-bom + ${jackson.version} + import + pom + + + org.eclipse.jetty + jetty-bom + 9.4.43.v20210629 + import + pom + + + io.netty + netty-bom + ${netty.version} + import + pom + + + com.google.protobuf + protobuf-bom + ${protobuf.version} + import + pom + + + io.grpc + grpc-bom + ${grpc.version} + pom + import + + + com.google.auth + google-auth-library-bom + 0.21.1 + pom + import + + + + org.apache.hadoop + hadoop-client + ${hadoop.version} + + + + log4j + log4j + + + org.eclipse.jetty + jetty-servlet + + + org.eclipse.jetty + jetty-webapp + + + javax.servlet.jsp + jsp-api + + + com.sun.jersey + jersey-servlet + + + org.jline + jline + + + org.apache.hadoop + hadoop-yarn-common + + + org.apache.hadoop + hadoop-yarn-api + + + org.apache.hadoop + hadoop-yarn-client + + + org.apache.kerby + kerb-core + + + org.apache.kerby + kerb-simplekdc + + + org.apache.curator + curator-client + + + org.apache.curator + curator-recipes + + + org.apache.curator + curator-framework + + + + + org.apache.avro + avro-mapred + ${avro.version} + provided + + + + org.apache.avro + avro-ipc + + + org.apache.avro + avro-ipc-jetty + + + + + + org.yaml + snakeyaml + ${snakeyaml.version} + + + com.google.guava + guava + ${guava.version} + + + commons-io + commons-io + 2.8.0 + + + commons-codec + commons-codec + ${commons-codec.version} + + + commons-io + commons-io + ${commons-io.version} + + + org.apache.commons + commons-lang3 + ${commons-lang3.version} + + + commons-collections + commons-collections + 3.2.2 + + + commons-logging + commons-logging + 1.2 + + + org.apache.commons + commons-compress + 1.21 + + + net.minidev + json-smart + 2.4.1 + + + joda-time + joda-time + 2.10.1 + + + org.xerial.snappy + snappy-java + 1.1.7.2 + + + com.google.api.grpc + proto-google-common-protos + 1.18.1 + + + mysql + mysql-connector-java + ${mysql.connector.version} + + + + org.apache.httpcomponents + httpcore + 4.4.13 + + + org.apache.httpcomponents + httpclient + 4.5.13 + + + com.google.auto.value + auto-value-annotations + 1.7.4 + + + com.google.http-client + google-http-client + 1.36.0 + + + com.nimbusds + nimbus-jose-jwt + 7.9 + + + org.codehaus.woodstox + stax2-api + 4.2.1 + + + com.google.code.gson + gson + 2.8.6 + + + com.amazonaws + aws-java-sdk-bundle + ${aws.sdk.version} + + + org.apache.avro + avro + ${avro.version} + + + org.objenesis + objenesis + 3.1 + + + com.github.luben + zstd-jni + 1.4.5-12 + + + org.slf4j + slf4j-api + ${slf4j.version} + + + org.apache.logging.log4j + log4j-api + ${log4j2.version} + + + org.jline + jline + ${jline.version} + + + + net.bytebuddy + byte-buddy + ${bytebuddy.version} + + + net.bytebuddy + byte-buddy-agent + ${bytebuddy.version} + + + org.javassist + javassist + 3.26.0-GA + + + junit + junit + ${junit.version} + + + org.mockito + mockito-core + ${mockito.version} + test + + + + org.apache.yetus + audience-annotations + 0.12.0 + + + org.reflections + reflections + ${reflections.version} + + + com.google.code.findbugs + annotations + ${findbugs.annotations.version} + + + com.google.code.findbugs + jsr305 + 3.0.2 + + + com.tngtech.archunit + archunit + ${archunit.version} + + + + javax.cache @@ -1163,13 +1641,6 @@ provided true - - com.fasterxml.jackson.core - jackson-core - ${jackson.version} - provided - true - org.snakeyaml snakeyaml-engine @@ -1180,15 +1651,24 @@ junit junit - ${junit.version} test true - + + org.hamcrest + hamcrest-library + ${hamcrest.version} + test + + + org.assertj + assertj-core + ${assertj.version} + test + org.mockito mockito-core - ${mockito.version} test @@ -1206,7 +1686,6 @@ org.reflections reflections - ${reflections.version} test @@ -1242,32 +1721,29 @@ com.google.code.findbugs annotations - ${findbugs.annotations.version} provided true net.bytebuddy byte-buddy - ${bytebuddy.version} - test - - - org.apache.commons - commons-lang3 - ${commons-lang3.version} test net.bytebuddy byte-buddy-agent - ${bytebuddy.version} test nl.jqno.equalsverifier equalsverifier - 1.7.8 + 3.5.5 + test + + + org.apache.tomcat.embed + tomcat-embed-core + 9.0.41 test