コード例 #1
0
  @Test
  public void testCreateDurableQueueUsingJMXAndRestartServer() throws Exception {
    String queueName = RandomUtil.randomString();
    String binding = RandomUtil.randomString();

    ActiveMQTestBase.checkNoBinding(context, binding);
    checkNoResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));

    JMSServerControl control = ManagementControlHelper.createJMSServerControl(mbeanServer);
    control.createQueue(queueName, binding);

    Object o = ActiveMQTestBase.checkBinding(context, binding);
    Assert.assertTrue(o instanceof Queue);
    Queue queue = (Queue) o;
    Assert.assertEquals(queueName, queue.getQueueName());
    checkResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));

    serverManager.stop();

    ActiveMQTestBase.checkNoBinding(context, binding);
    checkNoResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));

    serverManager = createJMSServer();
    serverManager.start();

    o = ActiveMQTestBase.checkBinding(context, binding);
    Assert.assertTrue(o instanceof Queue);
    queue = (Queue) o;
    Assert.assertEquals(queueName, queue.getQueueName());
    checkResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));
  }
  @Test
  public void testGetBindingNames() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    String divertName = RandomUtil.randomString();

    session.createQueue(address, queue, false);

    CoreMessagingProxy proxy = createProxy(address);
    Object[] bindingNames = (Object[]) proxy.retrieveAttributeValue("bindingNames");
    assertEquals(1, bindingNames.length);
    assertEquals(queue.toString(), bindingNames[0]);

    server
        .getActiveMQServerControl()
        .createDivert(
            divertName,
            randomString(),
            address.toString(),
            RandomUtil.randomString(),
            false,
            null,
            null);

    bindingNames = (Object[]) proxy.retrieveAttributeValue("bindingNames");
    assertEquals(2, bindingNames.length);

    session.deleteQueue(queue);

    bindingNames = (Object[]) proxy.retrieveAttributeValue("bindingNames");
    assertEquals(1, bindingNames.length);
    assertEquals(divertName.toString(), bindingNames[0]);
  }
コード例 #3
0
  @Test
  public void testMapWithArrayValues() throws Exception {
    String resource = RandomUtil.randomString();
    String operationName = RandomUtil.randomString();

    Map<String, Object> map = new HashMap<>();
    String key1 = RandomUtil.randomString();
    String[] val1 = new String[] {"a", "b", "c"};

    ManagementHelperTest.log.info("val1 type is " + Arrays.toString(val1));

    String key2 = RandomUtil.randomString();
    Long[] val2 = new Long[] {1L, 2L, 3L, 4L, 5L};

    ManagementHelperTest.log.info("val2 type is " + Arrays.toString(val2));

    map.put(key1, val1);
    map.put(key2, val2);

    Object[] params = new Object[] {"hello", map};

    Message msg = new ClientMessageImpl((byte) 0, false, 0, 0, (byte) 4, 1000);
    ManagementHelper.putOperationInvocation(msg, resource, operationName, params);

    Object[] parameters = ManagementHelper.retrieveOperationParameters(msg);

    Assert.assertEquals(params.length, parameters.length);

    Assert.assertEquals("hello", parameters[0]);

    Map map2 = (Map) parameters[1];
    Assert.assertEquals(2, map2.size());

    Object[] arr1 = (Object[]) map2.get(key1);
    Assert.assertEquals(val1.length, arr1.length);
    Assert.assertEquals(arr1[0], val1[0]);
    Assert.assertEquals(arr1[1], val1[1]);
    Assert.assertEquals(arr1[2], val1[2]);

    Object[] arr2 = (Object[]) map2.get(key2);
    Assert.assertEquals(val2.length, arr2.length);
    Assert.assertEquals(arr2[0], val2[0]);
    Assert.assertEquals(arr2[1], val2[1]);
    Assert.assertEquals(arr2[2], val2[2]);
  }
コード例 #4
0
  @Test
  public void testCreateDurableQueueUsingJMSAndRestartServer() throws Exception {
    String queueName = RandomUtil.randomString();
    String binding = RandomUtil.randomString();

    ActiveMQTestBase.checkNoBinding(context, binding);
    checkNoResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));

    TransportConfiguration config =
        new TransportConfiguration(InVMConnectorFactory.class.getName());
    Connection connection =
        ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, config)
            .createConnection();
    connection.start();
    Queue managementQueue = ActiveMQJMSClient.createQueue("activemq.management");
    QueueSession session = (QueueSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    QueueRequestor requestor = new QueueRequestor(session, managementQueue);
    Message message = session.createMessage();
    JMSManagementHelper.putOperationInvocation(
        message, "jms.server", "createQueue", queueName, binding);
    Message reply = requestor.request(message);
    Assert.assertTrue(JMSManagementHelper.hasOperationSucceeded(reply));
    connection.close();

    Object o = ActiveMQTestBase.checkBinding(context, binding);
    Assert.assertTrue(o instanceof Queue);
    Queue queue = (Queue) o;
    Assert.assertEquals(queueName, queue.getQueueName());
    checkResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));

    serverManager.stop();

    ActiveMQTestBase.checkNoBinding(context, binding);
    checkNoResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));

    serverManager = createJMSServer();
    serverManager.start();

    o = ActiveMQTestBase.checkBinding(context, binding);
    Assert.assertTrue(o instanceof Queue);
    queue = (Queue) o;
    Assert.assertEquals(queueName, queue.getQueueName());
    checkResource(ObjectNameBuilder.DEFAULT.getJMSQueueObjectName(queueName));
  }
コード例 #5
0
  @Test
  public void testSECURITY_AUTHENTICATION_VIOLATION() throws Exception {
    String unknownUser = RandomUtil.randomString();

    SecurityNotificationTest.flush(notifConsumer);

    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);

    try {
      sf.createSession(unknownUser, RandomUtil.randomString(), false, true, true, false, 1);
      Assert.fail("authentication must fail and a notification of security violation must be sent");
    } catch (Exception e) {
    }

    ClientMessage[] notifications = SecurityNotificationTest.consumeMessages(1, notifConsumer);
    Assert.assertEquals(
        SECURITY_AUTHENTICATION_VIOLATION.toString(),
        notifications[0].getObjectProperty(ManagementHelper.HDR_NOTIFICATION_TYPE).toString());
  }
  @Test
  public void testGetRoles() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    Role role =
        new Role(
            RandomUtil.randomString(),
            RandomUtil.randomBoolean(),
            RandomUtil.randomBoolean(),
            RandomUtil.randomBoolean(),
            RandomUtil.randomBoolean(),
            RandomUtil.randomBoolean(),
            RandomUtil.randomBoolean(),
            RandomUtil.randomBoolean());

    session.createQueue(address, queue, true);

    CoreMessagingProxy proxy = createProxy(address);
    Object[] roles = (Object[]) proxy.retrieveAttributeValue("roles");
    for (Object role2 : roles) {
      System.out.println(((Object[]) role2)[0]);
    }
    Assert.assertEquals(0, roles.length);

    Set<Role> newRoles = new HashSet<>();
    newRoles.add(role);
    server.getSecurityRepository().addMatch(address.toString(), newRoles);

    roles = (Object[]) proxy.retrieveAttributeValue("roles");
    Assert.assertEquals(1, roles.length);
    Object[] r = (Object[]) roles[0];
    Assert.assertEquals(role.getName(), r[0]);
    Assert.assertEquals(CheckType.SEND.hasRole(role), r[1]);
    Assert.assertEquals(CheckType.CONSUME.hasRole(role), r[2]);
    Assert.assertEquals(CheckType.CREATE_DURABLE_QUEUE.hasRole(role), r[3]);
    Assert.assertEquals(CheckType.DELETE_DURABLE_QUEUE.hasRole(role), r[4]);
    Assert.assertEquals(CheckType.CREATE_NON_DURABLE_QUEUE.hasRole(role), r[5]);
    Assert.assertEquals(CheckType.DELETE_NON_DURABLE_QUEUE.hasRole(role), r[6]);
    Assert.assertEquals(CheckType.MANAGE.hasRole(role), r[7]);

    session.deleteQueue(queue);
  }
コード例 #7
0
  @Test
  public void testArrayOfStringParameter() throws Exception {
    String resource = RandomUtil.randomString();
    String operationName = RandomUtil.randomString();
    String param = RandomUtil.randomString();
    String[] params =
        new String[] {
          RandomUtil.randomString(), RandomUtil.randomString(), RandomUtil.randomString()
        };
    Message msg = new ClientMessageImpl((byte) 0, false, 0, 0, (byte) 4, 1000);
    ManagementHelper.putOperationInvocation(msg, resource, operationName, param, params);

    Object[] parameters = ManagementHelper.retrieveOperationParameters(msg);
    Assert.assertEquals(2, parameters.length);
    Assert.assertEquals(param, parameters[0]);
    Object parameter_2 = parameters[1];
    ManagementHelperTest.log.info("type " + parameter_2);
    Assert.assertTrue(parameter_2 instanceof Object[]);
    Object[] retrievedParams = (Object[]) parameter_2;
    Assert.assertEquals(params.length, retrievedParams.length);
    for (int i = 0; i < retrievedParams.length; i++) {
      Assert.assertEquals(params[i], retrievedParams[i]);
    }
  }
  private void testSettersThrowException(final ActiveMQConnectionFactory cf) {

    String discoveryAddress = RandomUtil.randomString();
    int discoveryPort = RandomUtil.randomPositiveInt();
    long discoveryRefreshTimeout = RandomUtil.randomPositiveLong();
    String clientID = RandomUtil.randomString();
    long clientFailureCheckPeriod = RandomUtil.randomPositiveLong();
    long connectionTTL = RandomUtil.randomPositiveLong();
    long callTimeout = RandomUtil.randomPositiveLong();
    int minLargeMessageSize = RandomUtil.randomPositiveInt();
    int consumerWindowSize = RandomUtil.randomPositiveInt();
    int consumerMaxRate = RandomUtil.randomPositiveInt();
    int confirmationWindowSize = RandomUtil.randomPositiveInt();
    int producerMaxRate = RandomUtil.randomPositiveInt();
    boolean blockOnAcknowledge = RandomUtil.randomBoolean();
    boolean blockOnDurableSend = RandomUtil.randomBoolean();
    boolean blockOnNonDurableSend = RandomUtil.randomBoolean();
    boolean autoGroup = RandomUtil.randomBoolean();
    boolean preAcknowledge = RandomUtil.randomBoolean();
    String loadBalancingPolicyClassName = RandomUtil.randomString();
    int dupsOKBatchSize = RandomUtil.randomPositiveInt();
    int transactionBatchSize = RandomUtil.randomPositiveInt();
    long initialWaitTimeout = RandomUtil.randomPositiveLong();
    boolean useGlobalPools = RandomUtil.randomBoolean();
    int scheduledThreadPoolMaxSize = RandomUtil.randomPositiveInt();
    int threadPoolMaxSize = RandomUtil.randomPositiveInt();
    long retryInterval = RandomUtil.randomPositiveLong();
    double retryIntervalMultiplier = RandomUtil.randomDouble();
    int reconnectAttempts = RandomUtil.randomPositiveInt();
    boolean failoverOnServerShutdown = RandomUtil.randomBoolean();

    try {
      cf.setClientID(clientID);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setClientFailureCheckPeriod(clientFailureCheckPeriod);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setConnectionTTL(connectionTTL);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setCallTimeout(callTimeout);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setMinLargeMessageSize(minLargeMessageSize);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setConsumerWindowSize(consumerWindowSize);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setConsumerMaxRate(consumerMaxRate);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setConfirmationWindowSize(confirmationWindowSize);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setProducerMaxRate(producerMaxRate);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setBlockOnAcknowledge(blockOnAcknowledge);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setBlockOnDurableSend(blockOnDurableSend);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setBlockOnNonDurableSend(blockOnNonDurableSend);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setAutoGroup(autoGroup);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setPreAcknowledge(preAcknowledge);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setConnectionLoadBalancingPolicyClassName(loadBalancingPolicyClassName);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setDupsOKBatchSize(dupsOKBatchSize);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setTransactionBatchSize(transactionBatchSize);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setUseGlobalPools(useGlobalPools);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setScheduledThreadPoolMaxSize(scheduledThreadPoolMaxSize);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setThreadPoolMaxSize(threadPoolMaxSize);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setRetryInterval(retryInterval);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setRetryIntervalMultiplier(retryIntervalMultiplier);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }
    try {
      cf.setReconnectAttempts(reconnectAttempts);
      Assert.fail("Should throw exception");
    } catch (IllegalStateException e) {
      // OK
    }

    cf.getStaticConnectors();
    cf.getClientID();
    cf.getClientFailureCheckPeriod();
    cf.getConnectionTTL();
    cf.getCallTimeout();
    cf.getMinLargeMessageSize();
    cf.getConsumerWindowSize();
    cf.getConsumerMaxRate();
    cf.getConfirmationWindowSize();
    cf.getProducerMaxRate();
    cf.isBlockOnAcknowledge();
    cf.isBlockOnDurableSend();
    cf.isBlockOnNonDurableSend();
    cf.isAutoGroup();
    cf.isPreAcknowledge();
    cf.getConnectionLoadBalancingPolicyClassName();
    cf.getDupsOKBatchSize();
    cf.getTransactionBatchSize();
    cf.isUseGlobalPools();
    cf.getScheduledThreadPoolMaxSize();
    cf.getThreadPoolMaxSize();
    cf.getRetryInterval();
    cf.getRetryIntervalMultiplier();
    cf.getReconnectAttempts();

    cf.close();
  }
  @Test
  public void testGettersAndSetters() {
    ActiveMQConnectionFactory cf =
        ActiveMQJMSClient.createConnectionFactoryWithoutHA(JMSFactoryType.CF, liveTC);

    long clientFailureCheckPeriod = RandomUtil.randomPositiveLong();
    long connectionTTL = RandomUtil.randomPositiveLong();
    long callTimeout = RandomUtil.randomPositiveLong();
    int minLargeMessageSize = RandomUtil.randomPositiveInt();
    int consumerWindowSize = RandomUtil.randomPositiveInt();
    int consumerMaxRate = RandomUtil.randomPositiveInt();
    int confirmationWindowSize = RandomUtil.randomPositiveInt();
    int producerMaxRate = RandomUtil.randomPositiveInt();
    boolean blockOnAcknowledge = RandomUtil.randomBoolean();
    boolean blockOnDurableSend = RandomUtil.randomBoolean();
    boolean blockOnNonDurableSend = RandomUtil.randomBoolean();
    boolean autoGroup = RandomUtil.randomBoolean();
    boolean preAcknowledge = RandomUtil.randomBoolean();
    String loadBalancingPolicyClassName = RandomUtil.randomString();
    boolean useGlobalPools = RandomUtil.randomBoolean();
    int scheduledThreadPoolMaxSize = RandomUtil.randomPositiveInt();
    int threadPoolMaxSize = RandomUtil.randomPositiveInt();
    long retryInterval = RandomUtil.randomPositiveLong();
    double retryIntervalMultiplier = RandomUtil.randomDouble();
    int reconnectAttempts = RandomUtil.randomPositiveInt();
    cf.setClientFailureCheckPeriod(clientFailureCheckPeriod);
    cf.setConnectionTTL(connectionTTL);
    cf.setCallTimeout(callTimeout);
    cf.setMinLargeMessageSize(minLargeMessageSize);
    cf.setConsumerWindowSize(consumerWindowSize);
    cf.setConsumerMaxRate(consumerMaxRate);
    cf.setConfirmationWindowSize(confirmationWindowSize);
    cf.setProducerMaxRate(producerMaxRate);
    cf.setBlockOnAcknowledge(blockOnAcknowledge);
    cf.setBlockOnDurableSend(blockOnDurableSend);
    cf.setBlockOnNonDurableSend(blockOnNonDurableSend);
    cf.setAutoGroup(autoGroup);
    cf.setPreAcknowledge(preAcknowledge);
    cf.setConnectionLoadBalancingPolicyClassName(loadBalancingPolicyClassName);
    cf.setUseGlobalPools(useGlobalPools);
    cf.setScheduledThreadPoolMaxSize(scheduledThreadPoolMaxSize);
    cf.setThreadPoolMaxSize(threadPoolMaxSize);
    cf.setRetryInterval(retryInterval);
    cf.setRetryIntervalMultiplier(retryIntervalMultiplier);
    cf.setReconnectAttempts(reconnectAttempts);
    Assert.assertEquals(clientFailureCheckPeriod, cf.getClientFailureCheckPeriod());
    Assert.assertEquals(connectionTTL, cf.getConnectionTTL());
    Assert.assertEquals(callTimeout, cf.getCallTimeout());
    Assert.assertEquals(minLargeMessageSize, cf.getMinLargeMessageSize());
    Assert.assertEquals(consumerWindowSize, cf.getConsumerWindowSize());
    Assert.assertEquals(consumerMaxRate, cf.getConsumerMaxRate());
    Assert.assertEquals(confirmationWindowSize, cf.getConfirmationWindowSize());
    Assert.assertEquals(producerMaxRate, cf.getProducerMaxRate());
    Assert.assertEquals(blockOnAcknowledge, cf.isBlockOnAcknowledge());
    Assert.assertEquals(blockOnDurableSend, cf.isBlockOnDurableSend());
    Assert.assertEquals(blockOnNonDurableSend, cf.isBlockOnNonDurableSend());
    Assert.assertEquals(autoGroup, cf.isAutoGroup());
    Assert.assertEquals(preAcknowledge, cf.isPreAcknowledge());
    Assert.assertEquals(
        loadBalancingPolicyClassName, cf.getConnectionLoadBalancingPolicyClassName());
    Assert.assertEquals(useGlobalPools, cf.isUseGlobalPools());
    Assert.assertEquals(scheduledThreadPoolMaxSize, cf.getScheduledThreadPoolMaxSize());
    Assert.assertEquals(threadPoolMaxSize, cf.getThreadPoolMaxSize());
    Assert.assertEquals(retryInterval, cf.getRetryInterval());
    Assert.assertEquals(retryIntervalMultiplier, cf.getRetryIntervalMultiplier(), 0.0001);
    Assert.assertEquals(reconnectAttempts, cf.getReconnectAttempts());

    cf.close();
  }
コード例 #10
0
  @Test
  public void testParams() throws Exception {
    String resource = RandomUtil.randomString();
    String operationName = RandomUtil.randomString();

    long i = RandomUtil.randomInt();
    String s = RandomUtil.randomString();
    double d = RandomUtil.randomDouble();
    boolean b = RandomUtil.randomBoolean();
    long l = RandomUtil.randomLong();
    Map<String, Object> map = new HashMap<>();
    String key1 = RandomUtil.randomString();
    int value1 = RandomUtil.randomInt();
    String key2 = RandomUtil.randomString();
    double value2 = RandomUtil.randomDouble();
    String key3 = RandomUtil.randomString();
    String value3 = RandomUtil.randomString();
    String key4 = RandomUtil.randomString();
    boolean value4 = RandomUtil.randomBoolean();
    String key5 = RandomUtil.randomString();
    long value5 = RandomUtil.randomLong();
    map.put(key1, value1);
    map.put(key2, value2);
    map.put(key3, value3);
    map.put(key4, value4);
    map.put(key5, value5);

    Map<String, Object> map2 = new HashMap<>();
    String key2_1 = RandomUtil.randomString();
    int value2_1 = RandomUtil.randomInt();
    String key2_2 = RandomUtil.randomString();
    double value2_2 = RandomUtil.randomDouble();
    String key2_3 = RandomUtil.randomString();
    String value2_3 = RandomUtil.randomString();
    String key2_4 = RandomUtil.randomString();
    boolean value2_4 = RandomUtil.randomBoolean();
    String key2_5 = RandomUtil.randomString();
    long value2_5 = RandomUtil.randomLong();
    map2.put(key2_1, value2_1);
    map2.put(key2_2, value2_2);
    map2.put(key2_3, value2_3);
    map2.put(key2_4, value2_4);
    map2.put(key2_5, value2_5);

    Map<String, Object> map3 = new HashMap<>();
    String key3_1 = RandomUtil.randomString();
    int value3_1 = RandomUtil.randomInt();
    String key3_2 = RandomUtil.randomString();
    double value3_2 = RandomUtil.randomDouble();
    String key3_3 = RandomUtil.randomString();
    String value3_3 = RandomUtil.randomString();
    String key3_4 = RandomUtil.randomString();
    boolean value3_4 = RandomUtil.randomBoolean();
    String key3_5 = RandomUtil.randomString();
    long value3_5 = RandomUtil.randomLong();
    map3.put(key3_1, value3_1);
    map3.put(key3_2, value3_2);
    map3.put(key3_3, value3_3);
    map3.put(key3_4, value3_4);
    map3.put(key3_5, value3_5);

    Map[] maps = new Map[] {map2, map3};

    String strElem0 = RandomUtil.randomString();
    String strElem1 = RandomUtil.randomString();
    String strElem2 = RandomUtil.randomString();

    String[] strArray = new String[] {strElem0, strElem1, strElem2};

    Object[] params = new Object[] {i, s, d, b, l, map, strArray, maps};

    Message msg = new ClientMessageImpl((byte) 0, false, 0, 0, (byte) 4, 1000);
    ManagementHelper.putOperationInvocation(msg, resource, operationName, params);

    Object[] parameters = ManagementHelper.retrieveOperationParameters(msg);

    Assert.assertEquals(params.length, parameters.length);

    Assert.assertEquals(i, parameters[0]);
    Assert.assertEquals(s, parameters[1]);
    Assert.assertEquals(d, parameters[2]);
    Assert.assertEquals(b, parameters[3]);
    Assert.assertEquals(l, parameters[4]);
    Map mapRes = (Map) parameters[5];
    Assert.assertEquals(map.size(), mapRes.size());
    Assert.assertEquals((long) value1, mapRes.get(key1));
    Assert.assertEquals(value2, mapRes.get(key2));
    Assert.assertEquals(value3, mapRes.get(key3));
    Assert.assertEquals(value4, mapRes.get(key4));
    Assert.assertEquals(value5, mapRes.get(key5));

    Object[] strArr2 = (Object[]) parameters[6];
    Assert.assertEquals(strArray.length, strArr2.length);
    Assert.assertEquals(strElem0, strArr2[0]);
    Assert.assertEquals(strElem1, strArr2[1]);
    Assert.assertEquals(strElem2, strArr2[2]);

    Object[] mapArray = (Object[]) parameters[7];
    Assert.assertEquals(2, mapArray.length);
    Map mapRes2 = (Map) mapArray[0];
    Assert.assertEquals(map2.size(), mapRes2.size());
    Assert.assertEquals((long) value2_1, mapRes2.get(key2_1));
    Assert.assertEquals(value2_2, mapRes2.get(key2_2));
    Assert.assertEquals(value2_3, mapRes2.get(key2_3));
    Assert.assertEquals(value2_4, mapRes2.get(key2_4));
    Assert.assertEquals(value2_5, mapRes2.get(key2_5));

    Map mapRes3 = (Map) mapArray[1];
    Assert.assertEquals(map3.size(), mapRes3.size());
    Assert.assertEquals((long) value3_1, mapRes3.get(key3_1));
    Assert.assertEquals(value3_2, mapRes3.get(key3_2));
    Assert.assertEquals(value3_3, mapRes3.get(key3_3));
    Assert.assertEquals(value3_4, mapRes3.get(key3_4));
    Assert.assertEquals(value3_5, mapRes3.get(key3_5));
  }