gt:         for (String key : empty.keys()) {
context: /*
  * JBoss, Home of Professional Open Source.
  * Copyright 2011, Red Hat Middleware LLC, and individual contributors
  * as indicated by the @author tags. See the copyright.txt file in the
  * distribution for a full listing of individual contributors.
  *
  * This is free software; you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License as
  * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
  package org.jboss.as.core.model.test.jvm;
  
  
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.ADD;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.NAME;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP_ADDR;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.READ_RESOURCE_DESCRIPTION_OPERATION;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.RECURSIVE;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.VALUE;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.WRITE_ATTRIBUTE_OPERATION;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  import org.jboss.as.controller.PathAddress;
  import org.jboss.as.core.model.test.AbstractCoreModelTest;
  import org.jboss.as.core.model.test.KernelServices;
  import org.jboss.as.core.model.test.KernelServicesBuilder;
  import org.jboss.as.core.model.test.ModelInitializer;
  import org.jboss.as.core.model.test.TestModelType;
  import org.jboss.as.model.test.ModelTestUtils;
  import org.jboss.dmr.ModelNode;
  import org.jboss.dmr.ModelType;
  import org.jboss.dmr.ValueExpression;
  import org.junit.Assert;
  import org.junit.Test;
  
  /**
   * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
   */
  public abstract class AbstractJvmModelTest extends AbstractCoreModelTest {
  
      private final TestModelType type;
      private final boolean server;
  
      protected AbstractJvmModelTest(TestModelType type, boolean server) {
          this.type = type;
          this.server = server;
      }
  
  
      @Test
      public void testReadResourceDescription() throws Exception {
          KernelServices kernelServices = createKernelServicesBuilder(type).build();
  
          //Just make sure we can read it all
          ModelNode op = createOperation(READ_RESOURCE_DESCRIPTION_OPERATION);
          op.get(RECURSIVE).set(true);
          kernelServices.executeForResult(op);
      }
  
      @Test
      public void testEmptyJvmAdd() throws Exception {
          doEmptyJvmAdd();
      }
  
      @Test
      public void testWriteType() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("IBM");
          Assert.assertEquals(value, writeTest(kernelServices, "type", value));
      }
  
      @Test
      public void testWriteAgentLib() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "agent-lib", value));
      }
  
      @Test
      public void testWriteAgentPath() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "agent-path", value));
      }
  
      @Test
      public void testWriteEnvClasspathIgnored() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode(true);
          Assert.assertEquals(value, writeTest(kernelServices, "env-classpath-ignored", value));
      }
  
      @Test
      public void testWriteJavaAgent() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "java-agent", value));
      }
  
      @Test
      public void testWriteJavaHome() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "java-home", value));
      }
  
      @Test
      public void testWriteStackSize() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "stack-size", value));
      }
  
      @Test
      public void testWriteHeapSize() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "heap-size", value));
      }
  
      @Test
      public void testWriteMaxHeapSize() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "max-heap-size", value));
      }
  
      @Test
      public void testWritePermGenSize() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "permgen-size", value));
      }
  
      @Test
      public void testWriteMaxPermGenSize() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode("abc");
          Assert.assertEquals(value, writeTest(kernelServices, "max-permgen-size", value));
      }
  
      @Test
      public void testWriteBadType() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode op = createWriteAttributeOperation("type", new ModelNode("XXX"));
          kernelServices.executeForFailure(op);
      }
  
      @Test
      public void testWriteJvmOptions() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode().add("-Xmx100m").add("-Xms30m");
          Assert.assertEquals(value, writeTest(kernelServices, "jvm-options", value));
      }
  
      @Test
      public void testWriteJvmOptionsWithExpression() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          String expression = "-Xmx${my.xmx:100}m";
          ModelNode value = new ModelNode().add(expression);
          Assert.assertEquals(new ModelNode().add(new ModelNode().set(new ValueExpression(expression))), writeTest(kernelServices, "jvm-options", value));
      }
  
      @Test
      public void testWriteEnvironmentVariables() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          ModelNode value = new ModelNode();
          value.get("ENV1").set("one");
          value.get("ENV2").set("two");
          Assert.assertEquals(value, writeTest(kernelServices, "environment-variables", value));
      }
  
      @Test
      public void testFullAdd() throws Exception {
          ModelNode typeValue = new ModelNode("IBM");
          ModelNode agentLibValue = new ModelNode("agentLib");
          ModelNode envClasspathIgnored = new ModelNode(true);
          ModelNode javaAgentValue = new ModelNode("javaAgent");
          ModelNode javaHomeValue = new ModelNode("javaHome");
          ModelNode stackSizeValue = new ModelNode("stackSize");
          ModelNode heapSizeValue = new ModelNode("heapSize");
          ModelNode maxHeapSizeValue = new ModelNode("maxHeapSize");
          ModelNode permgenSizeValue = new ModelNode("permGenSize");
          ModelNode maxPermSizeValue = new ModelNode("maxPermSize");
          ModelNode jvmOptionsValue = new ModelNode().add("-Xmx100m").add("-Xms30m");
          ModelNode environmentVariablesValue = new ModelNode();
          environmentVariablesValue.get("ENV1").set("one");
          environmentVariablesValue.get("ENV2").set("two");
  
          ModelNode debugEnabledValue = new ModelNode(true);
          ModelNode debugOptionsValue = new ModelNode("debugOptions");
  
          ModelNode op = createOperation(ADD);
          op.get("type").set(typeValue);
          op.get("agent-lib").set(agentLibValue);
          op.get("env-classpath-ignored").set(envClasspathIgnored);
          op.get("java-agent").set(javaAgentValue);
          op.get("java-home").set(javaHomeValue);
          op.get("stack-size").set(stackSizeValue);
          op.get("heap-size").set(heapSizeValue);
          op.get("max-heap-size").set(maxHeapSizeValue);
          op.get("permgen-size").set(permgenSizeValue);
          op.get("max-permgen-size").set(maxPermSizeValue);
          op.get("jvm-options").set(jvmOptionsValue);
          op.get("environment-variables").set(environmentVariablesValue);
          if (server) {
              op.get("debug-enabled").set(debugEnabledValue);
              op.get("debug-options").set(debugOptionsValue);
          }
  
          KernelServices kernelServices = createKernelServicesBuilder(type)
                  .setBootOperations(Collections.singletonList(op))
                  .setModelInitializer(getModelInitializer(), null)
                  .build();
          Assert.assertTrue(kernelServices.isSuccessfulBoot());
  
          ModelNode resource = getJvmResource(kernelServices);
  
          Assert.assertEquals(typeValue, resource.get("type"));
          Assert.assertEquals(agentLibValue, resource.get("agent-lib"));
          Assert.assertEquals(envClasspathIgnored, resource.get("env-classpath-ignored"));
          Assert.assertEquals(javaAgentValue, resource.get("java-agent"));
          Assert.assertEquals(javaHomeValue, resource.get("java-home"));
          Assert.assertEquals(stackSizeValue, resource.get("stack-size"));
          Assert.assertEquals(heapSizeValue, resource.get("heap-size"));
          Assert.assertEquals(maxHeapSizeValue, resource.get("max-heap-size"));
          Assert.assertEquals(permgenSizeValue, resource.get("permgen-size"));
          Assert.assertEquals(maxPermSizeValue, resource.get("max-permgen-size"));
          Assert.assertEquals(jvmOptionsValue, resource.get("jvm-options"));
          Assert.assertEquals(environmentVariablesValue, resource.get("environment-variables"));
          if (server) {
              Assert.assertEquals(debugEnabledValue, resource.get("debug-enabled"));
              Assert.assertEquals(debugOptionsValue, resource.get("debug-options"));
          }
      }
  
      @Test
      public void testAddSameJvmOption() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          kernelServices.executeForResult(createAddJvmOptionOperation("-Xoption"));
  
          Assert.assertEquals(new ModelNode().add("-Xoption"), getJvmResource(kernelServices).get("jvm-options"));
          kernelServices.executeForFailure(createAddJvmOptionOperation("-Xoption"));
          Assert.assertEquals(new ModelNode().add("-Xoption"), getJvmResource(kernelServices).get("jvm-options"));
      }
  
      @Test
      public void testAddJvmOptionWithExpression() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          kernelServices.executeForResult(createAddJvmOptionOperation("-X${myoption:option}"));
  
          ModelNode result = getJvmResource(kernelServices).get("jvm-options");
          Assert.assertEquals(ModelType.EXPRESSION, result.get(0).getType());
          Assert.assertEquals("-X${myoption:option}", result.get(0).asString());
      }
  
      @Test
      public void testRemoveJvmOption() throws Exception {
          KernelServices kernelServices = doEmptyJvmAdd();
          kernelServices.executeForResult(createAddJvmOptionOperation("-Xoption1"));
          kernelServices.executeForResult(createAddJvmOptionOperation("-Xoption2"));
          kernelServices.executeForResult(createAddJvmOptionOperation("-Xoption3"));
          ModelNode resource = getJvmResource(kernelServices);
          Assert.assertEquals(new ModelNode().add("-Xoption1").add("-Xoption2").add("-Xoption3"), resource.get("jvm-options"));
  
          kernelServices.executeForResult(createRemoveJvmOptionOperation("-Xoption2"));
          Assert.assertEquals(new ModelNode().add("-Xoption1").add("-Xoption3"), getJvmResource(kernelServices).get("jvm-options"));
          kernelServices.executeForResult(createRemoveJvmOptionOperation("-Xoption2"));
          Assert.assertEquals(new ModelNode().add("-Xoption1").add("-Xoption3"), getJvmResource(kernelServices).get("jvm-options"));
          kernelServices.executeForResult(createRemoveJvmOptionOperation("-Xoption1"));
          Assert.assertEquals(new ModelNode().add("-Xoption3"), getJvmResource(kernelServices).get("jvm-options"));
          kernelServices.executeForResult(createRemoveJvmOptionOperation("-Xoption3"));
          Assert.assertEquals(new ModelNode().setEmptyList(), getJvmResource(kernelServices).get("jvm-options"));
      }
  
      protected ModelNode createWriteAttributeOperation(String name, ModelNode value) {
          ModelNode op = createOperation(WRITE_ATTRIBUTE_OPERATION);
          op.get(NAME).set(name);
          op.get(VALUE).set(value);
          return op;
      }
  
      protected ModelNode createAddJvmOptionOperation(String option) {
          ModelNode op = createOperation("add-jvm-option");
          op.get("jvm-option").set(option);
          return op;
      }
  
      protected ModelNode createRemoveJvmOptionOperation(String option) {
          ModelNode op = createOperation("remove-jvm-option");
          op.get("jvm-option").set(option);
          return op;
      }
  
      protected KernelServices doEmptyJvmAdd() throws Exception {
          List<ModelNode> bootOps = new ArrayList<ModelNode>();
  
          bootOps.add(createOperation(ADD));
  
          KernelServices kernelServices = createKernelServicesBuilder(type)
                  .setBootOperations(bootOps)
                  .setModelInitializer(getModelInitializer(), null)
                  .build();
          Assert.assertTrue(kernelServices.isSuccessfulBoot());
  
          ModelNode resource = getJvmResource(kernelServices);
          Assert.assertTrue(resource.keys().size() > 0);
          for (String key : resource.keys()) {
              Assert.assertFalse(resource.hasDefined(key));
          }
          return kernelServices;
      }
  
      protected ModelInitializer getModelInitializer() {
          return null;
      }
  
  
      protected ModelNode writeTest(KernelServices kernelServices, String name, ModelNode value) throws Exception {
          kernelServices.executeForResult(createWriteAttributeOperation(name, value));
  
          ModelNode resource = getJvmResource(kernelServices);
  
          Assert.assertTrue(resource.keys().size() > 0);
          for (String key : resource.keys()) {
              boolean isApartFrom = key.equals(name);
              if (!isApartFrom) {
                  Assert.assertFalse(resource.hasDefined(key));
              } else {
                  Assert.assertTrue(resource.hasDefined(key));
              }
          }
  
          return resource.get(name);
      }
  
      protected ModelNode createOperation(String name, ModelNode addr) {
          ModelNode op = new ModelNode();
          op.get(OP).set(name);
          op.get(OP_ADDR).set(addr);
          return op;
      }
  
      protected ModelNode createOperation(String name) {
          return createOperation(name, getPathAddress("test"));
      }
  
      protected abstract ModelNode getPathAddress(String jvmName, String... subaddress);
  
      protected KernelServicesBuilder createKernelServicesBuilder() {
          return createKernelServicesBuilder(type);
      }
  
      protected ModelNode getJvmResource(KernelServices kernelServices) throws Exception {
          ModelNode model = kernelServices.readWholeModel(true);
          PathAddress addr = PathAddress.pathAddress(getPathAddress("test"));
          return ModelTestUtils.getSubModel(model, addr);
      }
  
      protected void checkFullJvm(ModelNode full) {
          Assert.assertTrue(full.isDefined());
  
          Assert.assertEquals("agentLib", full.get("agent-lib").asString());
          Assert.assertEquals("agentPath", full.get("agent-path").asString());
          if (server) {
              Assert.assertEquals(true, full.get("debug-enabled").asBoolean());
              Assert.assertEquals("debugOptions", full.get("debug-options").asString());
          } else {
              Assert.assertFalse(full.get("debug-enabled").isDefined());
              Assert.assertFalse(full.get("debug-options").isDefined());
          }
  
          Assert.assertEquals(true, full.get("env-classpath-ignored").asBoolean());
          Assert.assertEquals("heapSize", full.get("heap-size").asString());
          Assert.assertEquals("javaAgent", full.get("java-agent").asString());
          Assert.assertEquals("javaHome", full.get("java-home").asString());
          Assert.assertEquals("maxHeapSize", full.get("max-heap-size").asString());
          Assert.assertEquals("maxPermGenSize", full.get("max-permgen-size").asString());
          Assert.assertEquals("stackSize", full.get("stack-size").asString());
          Assert.assertEquals("SUN", full.get("type").asString());
  
          List<ModelNode> options = full.get("jvm-options").asList();
          Assert.assertEquals(3, options.size());
          Assert.assertEquals("option1", options.get(0).asString());
          Assert.assertEquals("option2", options.get(1).asString());
          Assert.assertEquals("option3", options.get(2).asString());
  
          List<ModelNode> environment = full.get("environment-variables").asList();
          Assert.assertEquals(2, environment.size());
          Assert.assertEquals("name1", environment.get(0).asProperty().getName());
          Assert.assertEquals("value1", environment.get(0).asProperty().getValue().asString());
          Assert.assertEquals("name2", environment.get(1).asProperty().getName());
          Assert.assertEquals("value2", environment.get(1).asProperty().getValue().asString());
  
          Assert.assertEquals("command-prefix", full.get("launch-command").asString());
      }
  
      protected void checkEmptyJvm(ModelNode empty) {
          Assert.assertTrue(empty.isDefined());
          Assert.assertTrue(empty.isDefined());
          Assert.assertTrue(empty.keys().size() > 1);
  