@Test
  public void testLoggingProfile() throws Exception {
    final KernelServices kernelServices = boot();
    final String handlerName = "test-file-handler";

    final File logFile = createLogFile();
    final File profileLogFile = createLogFile("profile.log");
    final ModelNode handlerAddress = createFileHandlerAddress(handlerName).toModelNode();
    final ModelNode profileHandlerAddress =
        createFileHandlerAddress(PROFILE, handlerName).toModelNode();

    // Add handlers
    addFileHandler(
        kernelServices, null, handlerName, org.jboss.logmanager.Level.INFO, logFile, true);
    addFileHandler(
        kernelServices,
        PROFILE,
        handlerName,
        org.jboss.logmanager.Level.INFO,
        profileLogFile,
        true);

    // Change the format
    ModelNode op =
        SubsystemOperations.createReadAttributeOperation(
            handlerAddress, AbstractHandlerDefinition.FORMATTER);
    final String defaultHandlerFormat =
        SubsystemOperations.readResultAsString(executeOperation(kernelServices, op));
    op =
        SubsystemOperations.createReadAttributeOperation(
            profileHandlerAddress, AbstractHandlerDefinition.FORMATTER);
    final String defaultProfileHandlerFormat =
        SubsystemOperations.readResultAsString(executeOperation(kernelServices, op));
    op =
        SubsystemOperations.createWriteAttributeOperation(
            handlerAddress, AbstractHandlerDefinition.FORMATTER, "%m%n");
    executeOperation(kernelServices, op);
    op =
        SubsystemOperations.createWriteAttributeOperation(
            profileHandlerAddress, AbstractHandlerDefinition.FORMATTER, "%m%n");
    executeOperation(kernelServices, op);

    // Log with and without profile
    final String msg = "This is a test message";
    doLog(null, LEVELS, msg);
    doLog(PROFILE, LEVELS, msg);

    // Reset the formatters
    op =
        SubsystemOperations.createWriteAttributeOperation(
            handlerAddress, AbstractHandlerDefinition.FORMATTER, defaultHandlerFormat);
    executeOperation(kernelServices, op);
    op =
        SubsystemOperations.createWriteAttributeOperation(
            profileHandlerAddress,
            AbstractHandlerDefinition.FORMATTER,
            defaultProfileHandlerFormat);
    executeOperation(kernelServices, op);

    // Remove the handler
    removeFileHandler(kernelServices, null, handlerName, true);
    removeFileHandler(kernelServices, PROFILE, handlerName, true);

    // Read the files to a string
    final String result = FileUtils.readFileToString(logFile);
    final String profileResult = FileUtils.readFileToString(profileLogFile);

    // Check generated log file
    assertTrue(result.contains(msg));
    assertTrue(profileResult.contains(msg));

    // The contents of the files should match
    assertTrue(
        String.format(
            "Contents don't match: %nResult:%n%s%nProfileResult%n%s", result, profileResult),
        result.equals(profileResult));
  }
  @Test
  public void testLegacyFilters() throws Exception {
    final KernelServices kernelServices = boot();
    final String fileHandlerName = "test-file-handler";

    // add new file logger so we can track logged messages
    final File logFile = createLogFile();
    final ModelNode handlerAddress = createFileHandlerAddress(fileHandlerName).toModelNode();
    addFileHandler(
        kernelServices, null, fileHandlerName, org.jboss.logmanager.Level.TRACE, logFile, true);
    // Write legacy filters
    for (Map.Entry<String, ModelNode> entry : FilterConversionTestCase.MAP.entrySet()) {
      // Validate the write-attribute operation
      ModelNode op =
          SubsystemOperations.createWriteAttributeOperation(
              handlerAddress, CommonAttributes.FILTER, entry.getValue());
      executeOperation(kernelServices, op);
      // Read the current value
      op =
          SubsystemOperations.createReadAttributeOperation(
              handlerAddress, CommonAttributes.FILTER_SPEC);
      String filterSpecResult =
          SubsystemOperations.readResultAsString(executeOperation(kernelServices, op));
      assertEquals(entry.getKey(), filterSpecResult);

      // Validate an add operation
      final ModelNode tempHandlerAddress = createConsoleHandlerAddress("temp").toModelNode();
      op = SubsystemOperations.createAddOperation(tempHandlerAddress);
      op.get(CommonAttributes.FILTER.getName()).set(entry.getValue());
      executeOperation(kernelServices, op);
      // Read the current value
      op =
          SubsystemOperations.createReadAttributeOperation(
              tempHandlerAddress, CommonAttributes.FILTER_SPEC);
      filterSpecResult =
          SubsystemOperations.readResultAsString(executeOperation(kernelServices, op));
      assertEquals(entry.getKey(), filterSpecResult);
      // Remove the temp handler
      op = SubsystemOperations.createRemoveOperation(tempHandlerAddress, true);
      executeOperation(kernelServices, op);

      // Add to a logger
      final ModelNode loggerAddress = createLoggerAddress("test-logger").toModelNode();
      op = SubsystemOperations.createAddOperation(loggerAddress);
      op.get(CommonAttributes.FILTER.getName()).set(entry.getValue());
      executeOperation(kernelServices, op);
      // Read the current value
      op =
          SubsystemOperations.createReadAttributeOperation(
              loggerAddress, CommonAttributes.FILTER_SPEC);
      filterSpecResult =
          SubsystemOperations.readResultAsString(executeOperation(kernelServices, op));
      assertEquals(entry.getKey(), filterSpecResult);

      // Remove the attribute
      op =
          SubsystemOperations.createUndefineAttributeOperation(
              loggerAddress, CommonAttributes.FILTER_SPEC);
      executeOperation(kernelServices, op);
      op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER);
      // Filter and filter spec should be undefined
      assertEquals(
          "Filter was not undefined",
          SubsystemOperations.UNDEFINED,
          SubsystemOperations.readResult(executeOperation(kernelServices, op)));
      op =
          SubsystemOperations.createReadAttributeOperation(
              loggerAddress, CommonAttributes.FILTER_SPEC);
      assertEquals(
          "Filter was not undefined",
          SubsystemOperations.UNDEFINED,
          SubsystemOperations.readResult(executeOperation(kernelServices, op)));

      // Test writing the attribute to the logger
      op =
          SubsystemOperations.createWriteAttributeOperation(
              loggerAddress, CommonAttributes.FILTER, entry.getValue());
      executeOperation(kernelServices, op);
      // Read the current value
      op =
          SubsystemOperations.createReadAttributeOperation(
              loggerAddress, CommonAttributes.FILTER_SPEC);
      filterSpecResult =
          SubsystemOperations.readResultAsString(executeOperation(kernelServices, op));
      assertEquals(entry.getKey(), filterSpecResult);

      // Remove the logger
      op = SubsystemOperations.createRemoveOperation(loggerAddress, true);
      executeOperation(kernelServices, op);
    }

    // Write new filters
    for (Map.Entry<String, ModelNode> entry : FilterConversionTestCase.MAP.entrySet()) {
      // Write to a handler
      ModelNode op =
          SubsystemOperations.createWriteAttributeOperation(
              handlerAddress, CommonAttributes.FILTER_SPEC, entry.getKey());
      executeOperation(kernelServices, op);
      // Read the current value
      op =
          SubsystemOperations.createReadAttributeOperation(handlerAddress, CommonAttributes.FILTER);
      ModelNode filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op));
      ModelTestUtils.compare(entry.getValue(), filterResult);

      // Validate an add operation
      final ModelNode tempHandlerAddress = createConsoleHandlerAddress("temp").toModelNode();
      op = SubsystemOperations.createAddOperation(tempHandlerAddress);
      op.get(CommonAttributes.FILTER_SPEC.getName()).set(entry.getKey());
      executeOperation(kernelServices, op);
      // Read the current value
      op =
          SubsystemOperations.createReadAttributeOperation(
              tempHandlerAddress, CommonAttributes.FILTER);
      filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op));
      ModelTestUtils.compare(entry.getValue(), filterResult);
      // Remove the temp handler
      op = SubsystemOperations.createRemoveOperation(tempHandlerAddress, true);
      executeOperation(kernelServices, op);

      // Add to a logger
      final ModelNode loggerAddress = createLoggerAddress("test-logger").toModelNode();
      op = SubsystemOperations.createAddOperation(loggerAddress);
      op.get(CommonAttributes.FILTER_SPEC.getName()).set(entry.getKey());
      executeOperation(kernelServices, op);
      // Read the current value
      op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER);
      filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op));
      ModelTestUtils.compare(entry.getValue(), filterResult);

      // Test writing the attribute to the logger
      op =
          SubsystemOperations.createWriteAttributeOperation(
              loggerAddress, CommonAttributes.FILTER_SPEC, entry.getKey());
      executeOperation(kernelServices, op);
      // Read the current value
      op = SubsystemOperations.createReadAttributeOperation(loggerAddress, CommonAttributes.FILTER);
      filterResult = SubsystemOperations.readResult(executeOperation(kernelServices, op));
      ModelTestUtils.compare(entry.getValue(), filterResult);

      // Remove the logger
      op = SubsystemOperations.createRemoveOperation(loggerAddress, true);
      executeOperation(kernelServices, op);
    }
    removeFileHandler(kernelServices, null, fileHandlerName, true);
  }