@Test
  public void testRegisterWikiMacroWhenGlobalVisibilityAndAllowed() throws Exception {
    final DefaultWikiMacro wikiMacro = generateWikiMacro(WikiMacroVisibility.GLOBAL);

    // Simulate a user with programming rights
    getMockery()
        .checking(
            new Expectations() {
              {
                allowing(mockDocumentAccessBridge).getCurrentWiki();
                will(returnValue("wiki"));
                allowing(mockDocumentAccessBridge).getCurrentUser();
                will(returnValue("dummy"));
                allowing(mockDocumentAccessBridge).setCurrentUser("dummy");
                allowing(mockWikiMacroFactory)
                    .isAllowed(wikiMacro.getDocumentReference(), WikiMacroVisibility.GLOBAL);
                will(returnValue(true));
              }
            });

    Assert.assertFalse(wikiMacroManager.hasWikiMacro(wikiMacro.getDocumentReference()));

    wikiMacroManager.registerWikiMacro(wikiMacro.getDocumentReference(), wikiMacro);
    Assert.assertTrue(wikiMacroManager.hasWikiMacro(wikiMacro.getDocumentReference()));

    Macro<?> registeredMacro = macroManager.getMacro(new MacroId("testwikimacro"));
    Assert.assertEquals(0, registeredMacro.compareTo(wikiMacro));

    wikiMacroManager.unregisterWikiMacro(wikiMacro.getDocumentReference());
    Assert.assertFalse(wikiMacroManager.hasWikiMacro(wikiMacro.getDocumentReference()));

    Assert.assertFalse(macroManager.exists(new MacroId("testwikimacro")));
  }
  @Override
  public void transform(Block rootBlock, TransformationContext context)
      throws TransformationException {
    // Create a macro execution context with all the information required for macros.
    MacroTransformationContext macroContext = new MacroTransformationContext(context);
    macroContext.setTransformation(this);

    // Counter to prevent infinite recursion if a macro generates the same macro for example.
    for (int recursions = 0; recursions < this.maxRecursions; ) {
      // 1) Get highest priority macro
      PriorityMacroBlockMatcher priorityMacroBlockMatcher =
          new PriorityMacroBlockMatcher(context.getSyntax());
      rootBlock.getFirstBlock(priorityMacroBlockMatcher, Block.Axes.DESCENDANT);

      // 2) Apply macros lookup errors
      if (priorityMacroBlockMatcher.errors != null) {
        for (MacroLookupExceptionElement error : priorityMacroBlockMatcher.errors) {
          if (error.exception instanceof MacroNotFoundException) {
            // Macro cannot be found. Generate an error message instead of the macro execution
            // result.
            // TODO: make it internationalized
            this.macroErrorManager.generateError(
                error.macroBlock,
                String.format("Unknown macro: %s.", error.macroBlock.getId()),
                String.format(
                    "The \"%s\" macro is not in the list of registered macros. Verify the spelling or "
                        + "contact your administrator.",
                    error.macroBlock.getId()));
            this.logger.debug(
                "Failed to locate the [{}] macro. Ignoring it.", error.macroBlock.getId());
          } else {
            // TODO: make it internationalized
            this.macroErrorManager.generateError(
                error.macroBlock,
                String.format("Invalid macro: %s.", error.macroBlock.getId()),
                error.exception);
            this.logger.debug(
                "Failed to instantiate the [{}] macro. Ignoring it.", error.macroBlock.getId());
          }
        }
      }

      MacroBlock macroBlock = priorityMacroBlockMatcher.block;

      if (macroBlock == null) {
        // Nothing left to do
        return;
      }

      Macro<?> macro = priorityMacroBlockMatcher.blockMacro;

      boolean incrementRecursions = macroBlock.getParent() instanceof MacroMarkerBlock;

      List<Block> newBlocks;
      try {
        // 3) Verify if we're in macro inline mode and if the macro supports it. If not, send an
        // error.
        if (macroBlock.isInline()) {
          macroContext.setInline(true);
          if (!macro.supportsInlineMode()) {
            // The macro doesn't support inline mode, raise a warning but continue.
            // The macro will not be executed and we generate an error message instead of the macro
            // execution result.
            this.macroErrorManager.generateError(
                macroBlock,
                "This is a standalone macro only and it cannot be used inline",
                "This macro generates standalone content. As a consequence you need to make sure to use a "
                    + "syntax that separates your macro from the content before and after it so that it's on a "
                    + "line by itself. For example in XWiki Syntax 2.0+ this means having 2 newline characters "
                    + "(a.k.a line breaks) separating your macro from the content before and after it.");
            this.logger.debug("The [{}] macro doesn't support inline mode.", macroBlock.getId());

            continue;
          }
        } else {
          macroContext.setInline(false);
        }

        // 4) Execute the highest priority macro
        macroContext.setCurrentMacroBlock(macroBlock);
        ((MutableRenderingContext) this.renderingContext).setCurrentBlock(macroBlock);

        // Populate and validate macro parameters.
        Object macroParameters = macro.getDescriptor().getParametersBeanClass().newInstance();
        try {
          this.beanManager.populate(macroParameters, macroBlock.getParameters());
        } catch (Throwable e) {
          // One macro parameter was invalid.
          // The macro will not be executed and we generate an error message instead of the macro
          // execution result.
          this.macroErrorManager.generateError(
              macroBlock,
              String.format(
                  "Invalid macro parameters used for the \"%s\" macro.", macroBlock.getId()),
              e);
          this.logger.debug(
              "Invalid macro parameter for the [{}] macro. Internal error: [{}].",
              macroBlock.getId(),
              e.getMessage());

          continue;
        }

        newBlocks = ((Macro) macro).execute(macroParameters, macroBlock.getContent(), macroContext);
      } catch (Throwable e) {
        // The Macro failed to execute.
        // The macro will not be executed and we generate an error message instead of the macro
        // execution result.
        // Note: We catch any Exception because we want to never break the whole rendering.
        this.macroErrorManager.generateError(
            macroBlock, String.format("Failed to execute the [%s] macro.", macroBlock.getId()), e);
        this.logger.debug(
            "Failed to execute the [{}] macro. Internal error [{}].",
            macroBlock.getId(),
            e.getMessage());

        continue;
      } finally {
        ((MutableRenderingContext) this.renderingContext).setCurrentBlock(null);
      }

      // We wrap the blocks generated by the macro execution with MacroMarker blocks so that
      // listeners/renderers
      // who wish to know the group of blocks that makes up the executed macro can. For example this
      // is useful for
      // the XWiki Syntax renderer so that it can reconstruct the macros from the transformed XDOM.
      Block resultBlock = wrapInMacroMarker(macroBlock, newBlocks);

      // 5) Replace the MacroBlock by the Blocks generated by the execution of the Macro
      macroBlock.getParent().replaceChild(resultBlock, macroBlock);

      if (incrementRecursions) {
        ++recursions;
      }
    }
  }