diff --git a/src/main/java/org/apache/tomee/website/ApisUsed.java b/src/main/java/org/apache/tomee/website/ApisUsed.java
new file mode 100644
index 0000000..08d24a9
--- /dev/null
+++ b/src/main/java/org/apache/tomee/website/ApisUsed.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.tomee.website;
+
+import org.tomitribe.util.PrintString;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ApisUsed {
+
+    private static final Pattern HEADER = Pattern.compile("\n=+ *apis +used *\n", Pattern.CASE_INSENSITIVE);
+
+    public static String insertHref(String source, final String link, final String linkText) {
+        source = normalize(source);
+
+        if (source.contains("\n= APIs Used\n")) {
+            return updateApiList(source, link, linkText);
+        } else {
+            return addApiList(source, link, linkText);
+        }
+    }
+
+    private static String addApiList(final String source, final String link, final String linkText) {
+        final PrintString out = new PrintString();
+        out.println("");
+        out.println("= APIs Used");
+        out.println("");
+        out.printf("- link:%s[%s]%n", link, linkText);
+
+        return source + out.toString();
+    }
+
+    private static String updateApiList(final String source, final String link, final String linkText) {
+        final int start = source.indexOf("\n= APIs Used\n");
+        final int end = ExampleLinks.min(source.indexOf("\n=", start + 1), source.length());
+        final String content = source.substring(start, end);
+
+        /*
+         * Do not add this link if there already one with the same title
+         */
+        if (content.contains(String.format("[%s]", linkText))) return source;
+
+        final String updated = content + String.format("- link:%s[%s]%n", link, linkText);
+
+        return source.replace(content, updated);
+    }
+
+    protected static String normalize(final String source) {
+        final Matcher matcher = HEADER.matcher(source);
+        if (!matcher.find()) return source;
+
+        return matcher.replaceAll("\n= APIs Used\n");
+    }
+}
diff --git a/src/main/java/org/apache/tomee/website/Configuration.java b/src/main/java/org/apache/tomee/website/Configuration.java
index 1b90fac..a182043 100644
--- a/src/main/java/org/apache/tomee/website/Configuration.java
+++ b/src/main/java/org/apache/tomee/website/Configuration.java
@@ -92,12 +92,12 @@
         return new Source[]{
 //                new Source("https://github.com/apache/tomee.git", "master", "tomee-8.0"),
                 new Source("https://github.com/apache/tomee.git", "master", "tomee-9.0").label("milestone").related(microProfile2).related(jakartaEE9).javadoc("^org.apache.(openejb|tomee).*"),
-                new Source("https://github.com/apache/tomee.git", "master", "tomee-8.0", true).related(microProfile2).related(jakartaEE8).javadoc("^org.apache.(openejb|tomee).*"),
-                new Source("https://github.com/apache/tomee.git", "tomee-7.1.0", "tomee-7.1").javadoc("^org.apache.(openejb|tomee).*"),
-                new Source("https://github.com/apache/tomee.git", "tomee-7.0.5", "tomee-7.0").javadoc("^org.apache.(openejb|tomee).*"),
-                new Source("https://github.com/apache/tomee.git", "master", "master").javadoc("^org.apache.(openejb|tomee).*"),
-                new Source("https://github.com/eclipse/microprofile-bom.git", "master", "microprofile-2.0").related(microProfile2).javadoc("^org.eclipse.microprofile.*"),
-                new Source("https://github.com/eclipse-ee4j/jakartaee-platform.git", "v8", "jakartaee-8.0").related(jakartaEE8).javadoc("^javax.*"),
+//                new Source("https://github.com/apache/tomee.git", "master", "tomee-8.0", true).related(microProfile2).related(jakartaEE8).javadoc("^org.apache.(openejb|tomee).*"),
+//                new Source("https://github.com/apache/tomee.git", "tomee-7.1.0", "tomee-7.1").javadoc("^org.apache.(openejb|tomee).*"),
+//                new Source("https://github.com/apache/tomee.git", "tomee-7.0.5", "tomee-7.0").javadoc("^org.apache.(openejb|tomee).*"),
+//                new Source("https://github.com/apache/tomee.git", "master", "master").javadoc("^org.apache.(openejb|tomee).*"),
+//                new Source("https://github.com/eclipse/microprofile-bom.git", "master", "microprofile-2.0").related(microProfile2).javadoc("^org.eclipse.microprofile.*"),
+//                new Source("https://github.com/eclipse-ee4j/jakartaee-platform.git", "v8", "jakartaee-8.0").related(jakartaEE8).javadoc("^javax.*"),
                 new Source("https://github.com/eclipse-ee4j/jakartaee-platform.git", "master", "jakartaee-9.0").related(jakartaEE9).javadoc("^jakarta.*")
         };
     }
diff --git a/src/main/java/org/apache/tomee/website/SeeLinks.java b/src/main/java/org/apache/tomee/website/ExampleLinks.java
similarity index 64%
rename from src/main/java/org/apache/tomee/website/SeeLinks.java
rename to src/main/java/org/apache/tomee/website/ExampleLinks.java
index 9979361..0044a7a 100644
--- a/src/main/java/org/apache/tomee/website/SeeLinks.java
+++ b/src/main/java/org/apache/tomee/website/ExampleLinks.java
@@ -16,18 +16,26 @@
  */
 package org.apache.tomee.website;
 
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
+import org.tomitribe.swizzle.stream.StreamLexer;
+import org.tomitribe.util.IO;
+import org.tomitribe.util.Join;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 /**
- * Utility class to insert additional @see links into java source code.
+ * Utility class to insert additional @example links into java source code.
  * If no Javadoc exists at the class level, some will be added.
+ *
+ * The @example tag is a custom javadoc tag that creates various "Examples" sections
+ * in the generated javadoc.
  */
-public class SeeLinks {
+public class ExampleLinks {
 
     public static String insertHref(final String source, final String link, final String linkText) {
         final int start = Math.max(source.lastIndexOf("\nimport "), source.indexOf("\npackage "));
-        final int end = min(source.indexOf("\npublic "), source.indexOf("\n@"));
+        final int end = min(min(source.indexOf("\npublic "), source.indexOf("\n@")), source.indexOf("\nfinal"));
 
         final String header = source.substring(start, end);
 
@@ -38,7 +46,10 @@
         }
     }
 
-    private static int min(final int a, final int b) {
+    /**
+     * Returns the lowest viable index
+     */
+    public static int min(final int a, final int b) {
         if (a == -1) return b;
         if (b == -1) return a;
         return Math.min(a, b);
@@ -46,7 +57,7 @@
 
     private static String addComment(final String source, final String link, final String linkText, final String header) {
         final String href = href(link, linkText);
-        final String comment = header + "\n/**" + href + "\n */";
+        final String comment = header + "\n/**\n" + href + "\n */";
         return source.replace(header, comment);
     }
 
@@ -56,22 +67,27 @@
          */
         if (header.contains(String.format(">%s</a>", linkText))) return source;
 
-        final Pattern commentPattern = Pattern.compile("/\\*\\*(.*\n*)*?\n *\\*/");
-        final Matcher matcher = commentPattern.matcher(header);
-        if (!matcher.find()) return source;
-
-        final String comment = matcher.group(0);
+        final StreamLexer lexer = new StreamLexer(IO.read(header));
+        final String comment;
+        try {
+            comment = lexer.readToken("/**", "*/");
+        } catch (Exception e) {
+            throw new IllegalStateException(e);
+        }
 
         final String href = href(link, linkText);
 
-        final String updatedComment = comment.replaceFirst("(\n *\\*/)", href + "$1");
+        final List<String> lines = new ArrayList<>(Arrays.asList(comment.split("\n")));
+        lines.add(lines.size() - 1, href);
+
+        final String updatedComment = Join.join("\n", lines);
 
         // TODO
         return source.replace(comment, updatedComment);
     }
 
     private static String href(final String link, final String linkText) {
-        final String href = String.format("\n * @see <a href=\"%s\">%s</a>", link, linkText);
+        final String href = String.format(" * @example <a href=\"%s\">%s</a>", link, linkText);
         return href;
     }
 }
diff --git a/src/main/java/org/apache/tomee/website/Javadocs.java b/src/main/java/org/apache/tomee/website/Javadocs.java
index 5198e63..ae187d9 100644
--- a/src/main/java/org/apache/tomee/website/Javadocs.java
+++ b/src/main/java/org/apache/tomee/website/Javadocs.java
@@ -92,6 +92,8 @@
             final File javadocOutput = sources.getGeneratedDestFor(source, "javadoc");
             final ProcessBuilder cmd = new ProcessBuilder(
                     getJavadocCommand().getAbsolutePath(),
+                    "-tag",
+                    "example:a:Examples:",
                     "-sourcepath",
                     javaSources.getAbsolutePath(),
                     "-d",
diff --git a/src/main/java/org/apache/tomee/website/LearningLinks.java b/src/main/java/org/apache/tomee/website/LearningLinks.java
index 1f2614c..9f170f4 100644
--- a/src/main/java/org/apache/tomee/website/LearningLinks.java
+++ b/src/main/java/org/apache/tomee/website/LearningLinks.java
@@ -21,11 +21,14 @@
 import org.tomitribe.tio.Match;
 import org.tomitribe.tio.lang.JvmLang;
 
+import java.io.File;
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -99,7 +102,60 @@
     }
 
     private void addApisUsed(final Example example, final List<String> apisUsed, final Map<String, JavadocSource> sources, final Source source) {
-        // TODO
+        Collections.sort(apisUsed);
+
+        String content = null;
+        try {
+            content = IO.slurp(example.getDestReadme());
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+
+        final String basePath = pathToContentRoot(example.getDestReadme());
+
+        final List<JavadocSource> list = apisUsed.stream()
+                .map(sources::get)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+
+        for (JavadocSource javadocSource : list) {
+            final String link = String.format("%s%s/javadoc/%s.html",
+                    basePath,
+                    source.getName(),
+                    javadocSource.getClassName().replace(".", "/"));
+
+            content = ApisUsed.insertHref(content, link, javadocSource.getClassName());
+        }
+
+        try {
+            IO.copy(IO.read(content), example.getDestReadme());
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    static String pathToContentRoot(final File file) {
+        final StringBuilder sb = new StringBuilder();
+
+        File parent = file;
+        while ((parent = parent.getParentFile()) != null && !parent.getName().equals("content")) {
+            sb.append("../");
+        }
+
+        return sb.toString();
+    }
+
+    static String pathFromContentRoot(final File file) {
+        final String absolutePath = file.getAbsolutePath();
+
+        final String content = "/content/";
+        final int indexOfContent = absolutePath.indexOf(content);
+
+        if (indexOfContent == -1) {
+            throw new IllegalStateException("Expected '/content/' section of path not found: " + absolutePath);
+        }
+
+        return absolutePath.substring(indexOfContent + content.length());
     }
 
 
@@ -107,18 +163,23 @@
         try {
             final String content = IO.slurp(javadocSource.getSourceFile());
 
-            // TODO this link won't resolve as-is, it needs to be relative
-            final String link = example.getHref();
+            final String toContentRoot = pathToContentRoot(javadocSource.getSourceFile());
+            final String fromContentRoot = pathFromContentRoot(example.getDestReadme())
+                    .replace(".adoc", ".html")
+                    .replace(".md", ".html");
+
+            final String link = toContentRoot + fromContentRoot;
 
             final String name = example.getName();
 
+
             // Update the source contents to include an href link
-            final String modified = SeeLinks.insertHref(content, link, name);
+            final String modified = ExampleLinks.insertHref(content, link, name);
 
             // Overwrite the source with the newly linked version
             IO.copy(IO.read(modified), javadocSource.getSourceFile());
-        } catch (IOException e) {
-            throw new UncheckedIOException("Unable to add link to example: " + example.getName(), e);
+        } catch (Exception e) {
+            throw new IllegalStateException("Unable to add link to java source: " + javadocSource.getSourceFile().getAbsolutePath(), e);
         }
     }
 
@@ -162,4 +223,5 @@
 
     }
 
+
 }
diff --git a/src/main/java/org/apache/tomee/website/Sources.java b/src/main/java/org/apache/tomee/website/Sources.java
index 579790d..b0bd03a 100644
--- a/src/main/java/org/apache/tomee/website/Sources.java
+++ b/src/main/java/org/apache/tomee/website/Sources.java
@@ -157,6 +157,7 @@
                 .flatMap(Source::stream)
                 .map(Source::getPerform)
                 .flatMap(Collection::stream)
+                .peek(runnable -> System.out.println("Running Hook " + runnable))
                 .forEach(Runnable::run);
 
         VersionsIndex.prepare(this);
diff --git a/src/test/java/org/apache/tomee/website/ApisUsedTest.java b/src/test/java/org/apache/tomee/website/ApisUsedTest.java
new file mode 100644
index 0000000..6807e5b
--- /dev/null
+++ b/src/test/java/org/apache/tomee/website/ApisUsedTest.java
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.tomee.website;
+
+import org.junit.Test;
+
+import static org.apache.tomee.website.Scenario.scenario;
+import static org.junit.Assert.assertEquals;
+
+public class ApisUsedTest {
+
+
+    /**
+     * If an "APIs Used" section exists, but uses slightly different
+     * formatting, we should normalize it so it is consistent with
+     * all the other "APIs Used" sections
+     */
+    @Test
+    public void abnormalHeading() throws Exception {
+        final Scenario scenario = scenario(ApisUsedTest.class, "abnormalHeading");
+
+        final String input = scenario.get("before.adoc");
+
+        final String actual = ApisUsed.insertHref(input, "../../../jakartaee-9.0/javadoc/jakarta/persistence/EntityManager.html", "jakarta.persistence.EntityManager");
+
+        assertEquals(scenario.get("after.adoc"), actual);
+    }
+
+    /**
+     * If an "APIs Used" section exists in the middle of a document
+     * and therefore has sections after it, we should update the
+     * section where it lives and not move it or mistakenly append
+     * another "APIs Used" section.
+     */
+    @Test
+    public void hasOtherSections() throws Exception {
+        final Scenario scenario = scenario(ApisUsedTest.class, "hasOtherSections");
+
+        final String input = scenario.get("before.adoc");
+
+        final String actual = ApisUsed.insertHref(input, "../../../jakartaee-9.0/javadoc/jakarta/persistence/EntityManager.html", "jakarta.persistence.EntityManager");
+
+        assertEquals(scenario.get("after.adoc"), actual);
+    }
+
+    /**
+     * Very basic happy-path test to add an "APIs Used" section
+     * to a document that doesn't yet have one.
+     */
+    @Test
+    public void insertHref() throws Exception {
+        final Scenario scenario = scenario(ApisUsedTest.class, "insertHref");
+
+        final String input = scenario.get("before.adoc");
+
+        final String actual = ApisUsed.insertHref(input, "../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html", "jakarta.persistence.Entity");
+
+        assertEquals(scenario.get("after.adoc"), actual);
+    }
+
+    /**
+     * We should be able to insert links into the "APIs Used"
+     * section in several different calls.  The first call
+     * will add the section and the subsequent calls will
+     * update the now-existing section.
+     */
+    @Test
+    public void multipleInserts() throws Exception {
+        final Scenario scenario = scenario(ApisUsedTest.class, "multipleInserts");
+
+        final String input = scenario.get("before.adoc");
+
+        final String after1 = ApisUsed.insertHref(input,
+                "../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html",
+                "jakarta.persistence.Entity");
+        assertEquals(scenario.get("after1.adoc"), after1);
+
+        final String after2 = ApisUsed.insertHref(after1,
+                "../../../jakartaee-9.0/javadoc/jakarta/persistence/EntityManager.html",
+                "jakarta.persistence.EntityManager");
+        assertEquals(scenario.get("after2.adoc"), after2);
+
+        final String after3 = ApisUsed.insertHref(after2,
+                "../../../jakartaee-9.0/javadoc/jakarta/persistence/Id.html",
+                "jakarta.persistence.Id");
+        assertEquals(scenario.get("after3.adoc"), after3);
+    }
+
+    /**
+     * If an API is already listed in the "APIs Used" section we should
+     * not add it again.
+     */
+    @Test
+    public void noDuplicates() throws Exception {
+        final Scenario scenario = scenario(ApisUsedTest.class, "noDuplicates");
+
+        final String input = scenario.get("before.adoc");
+
+        final String after1 = ApisUsed.insertHref(input, "../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html", "jakarta.persistence.Entity");
+
+        assertEquals(scenario.get("after.adoc"), after1);
+
+        final String after2 = ApisUsed.insertHref(after1, "../../../jakartaee-8.0/javadoc/jakarta/persistence/Entity.html", "jakarta.persistence.Entity");
+
+        assertEquals(scenario.get("after.adoc"), after2);
+    }
+
+    @Test
+    public void normalize() throws Exception {
+        assertEquals("\n= APIs Used\n- link", ApisUsed.normalize("\n====  ApIs usEd\n- link"));
+    }
+
+}
diff --git a/src/test/java/org/apache/tomee/website/SeeLinksTest.java b/src/test/java/org/apache/tomee/website/ExampleLinksTest.java
similarity index 66%
rename from src/test/java/org/apache/tomee/website/SeeLinksTest.java
rename to src/test/java/org/apache/tomee/website/ExampleLinksTest.java
index e740239..3b15094 100644
--- a/src/test/java/org/apache/tomee/website/SeeLinksTest.java
+++ b/src/test/java/org/apache/tomee/website/ExampleLinksTest.java
@@ -25,18 +25,18 @@
 import static org.junit.Assert.assertEquals;
 
 @Ignore
-public class SeeLinksTest {
+public class ExampleLinksTest {
 
     /**
      * Test we can insert an @see link into some code that already has some javadoc
      */
     @Test
     public void insertHref() throws IOException {
-        final Scenario scenario = scenario(SeeLinksTest.class, "insertHref");
+        final Scenario scenario = scenario(ExampleLinksTest.class, "insertHref");
 
         final String input = scenario.get("before.java");
 
-        final String actual = SeeLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
+        final String actual = ExampleLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
 
         assertEquals(scenario.get("after.java"), actual);
     }
@@ -46,11 +46,11 @@
      */
     @Test
     public void noJavadoc() throws IOException {
-        final Scenario scenario = scenario(SeeLinksTest.class, "noJavadoc");
+        final Scenario scenario = scenario(ExampleLinksTest.class, "noJavadoc");
 
         final String input = scenario.get("before.java");
 
-        final String actual = SeeLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
+        final String actual = ExampleLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
 
         assertEquals(scenario.get("after.java"), actual);
     }
@@ -60,17 +60,17 @@
      */
     @Test
     public void multipleInserts() throws IOException {
-        final Scenario scenario = scenario(SeeLinksTest.class, "multipleInserts");
+        final Scenario scenario = scenario(ExampleLinksTest.class, "multipleInserts");
 
         final String input = scenario.get("before.java");
 
-        final String after1 = SeeLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
+        final String after1 = ExampleLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
         assertEquals(scenario.get("after1.java"), after1);
 
-        final String after2 = SeeLinks.insertHref(after1, "http://example.org/red.html", "Red Sample");
+        final String after2 = ExampleLinks.insertHref(after1, "http://example.org/red.html", "Red Sample");
         assertEquals(scenario.get("after2.java"), after2);
 
-        final String after3 = SeeLinks.insertHref(after2, "http://example.org/yellow.html", "yellow");
+        final String after3 = ExampleLinks.insertHref(after2, "http://example.org/yellow.html", "yellow");
         assertEquals(scenario.get("after3.java"), after3);
     }
 
@@ -79,15 +79,15 @@
      */
     @Test
     public void noDuplicates() throws IOException {
-        final Scenario scenario = scenario(SeeLinksTest.class, "noDuplicates");
+        final Scenario scenario = scenario(ExampleLinksTest.class, "noDuplicates");
 
         final String input = scenario.get("before.java");
 
-        final String after1 = SeeLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
+        final String after1 = ExampleLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
         assertEquals(scenario.get("after.java"), after1);
 
         // The second insert should be ignored as it has the same title "Orange Example"
-        final String after2 = SeeLinks.insertHref(after1, "http://example.org/foo.html", "Orange Example");
+        final String after2 = ExampleLinks.insertHref(after1, "http://example.org/foo.html", "Orange Example");
         assertEquals(scenario.get("after.java"), after2);
     }
 
@@ -96,11 +96,11 @@
      */
     @Test
     public void hasAnnotations() throws IOException {
-        final Scenario scenario = scenario(SeeLinksTest.class, "hasAnnotations");
+        final Scenario scenario = scenario(ExampleLinksTest.class, "hasAnnotations");
 
         final String input = scenario.get("before.java");
 
-        final String actual = SeeLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
+        final String actual = ExampleLinks.insertHref(input, "http://example.org/orange.html", "Orange Example");
         assertEquals(scenario.get("after.java"), actual);
     }
 
diff --git a/src/test/java/org/apache/tomee/website/LearningLinksTest.java b/src/test/java/org/apache/tomee/website/LearningLinksTest.java
new file mode 100644
index 0000000..09e8b37
--- /dev/null
+++ b/src/test/java/org/apache/tomee/website/LearningLinksTest.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.tomee.website;
+
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+
+public class LearningLinksTest {
+
+    @Test
+    public void pathToContentRoot() {
+        final File file = new File("tomee-site-generator/target/jbake/content/tomee-9.0/pt/examples/injection-of-entitymanager.adoc");
+        final String basePath = LearningLinks.pathToContentRoot(file);
+        assertEquals("../../../", basePath);
+    }
+
+    @Test
+    public void pathFromContentRoot() {
+        final File file = new File("tomee-site-generator/target/jbake/content/tomee-9.0/pt/examples/injection-of-entitymanager.adoc");
+        final String basePath = LearningLinks.pathFromContentRoot(file);
+        assertEquals("tomee-9.0/pt/examples/injection-of-entitymanager.adoc", basePath);
+    }
+}
diff --git a/src/test/resources/ApisUsedTest/abnormalHeading/after.adoc b/src/test/resources/ApisUsedTest/abnormalHeading/after.adoc
new file mode 100644
index 0000000..9a6d5db
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/abnormalHeading/after.adoc
@@ -0,0 +1,230 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/EntityManager.html[jakarta.persistence.EntityManager]
diff --git a/src/test/resources/ApisUsedTest/abnormalHeading/before.adoc b/src/test/resources/ApisUsedTest/abnormalHeading/before.adoc
new file mode 100644
index 0000000..7c72a68
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/abnormalHeading/before.adoc
@@ -0,0 +1,229 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+====  ApIs usEd
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
diff --git a/src/test/resources/ApisUsedTest/hasOtherSections/after.adoc b/src/test/resources/ApisUsedTest/hasOtherSections/after.adoc
new file mode 100644
index 0000000..f6e1e43
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/hasOtherSections/after.adoc
@@ -0,0 +1,235 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/EntityManager.html[jakarta.persistence.EntityManager]
+
+= Related Examples
+
+- link:foo.html
\ No newline at end of file
diff --git a/src/test/resources/ApisUsedTest/hasOtherSections/before.adoc b/src/test/resources/ApisUsedTest/hasOtherSections/before.adoc
new file mode 100644
index 0000000..7966535
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/hasOtherSections/before.adoc
@@ -0,0 +1,234 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
+
+= Related Examples
+
+- link:foo.html
\ No newline at end of file
diff --git a/src/test/resources/ApisUsedTest/insertHref/after.adoc b/src/test/resources/ApisUsedTest/insertHref/after.adoc
new file mode 100644
index 0000000..f83a09d
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/insertHref/after.adoc
@@ -0,0 +1,230 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
diff --git a/src/test/resources/ApisUsedTest/insertHref/before.adoc b/src/test/resources/ApisUsedTest/insertHref/before.adoc
new file mode 100644
index 0000000..5a86e09
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/insertHref/before.adoc
@@ -0,0 +1,226 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
diff --git a/src/test/resources/ApisUsedTest/multipleInserts/after1.adoc b/src/test/resources/ApisUsedTest/multipleInserts/after1.adoc
new file mode 100644
index 0000000..f83a09d
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/multipleInserts/after1.adoc
@@ -0,0 +1,230 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
diff --git a/src/test/resources/ApisUsedTest/multipleInserts/after2.adoc b/src/test/resources/ApisUsedTest/multipleInserts/after2.adoc
new file mode 100644
index 0000000..95aaa88
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/multipleInserts/after2.adoc
@@ -0,0 +1,231 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/EntityManager.html[jakarta.persistence.EntityManager]
diff --git a/src/test/resources/ApisUsedTest/multipleInserts/after3.adoc b/src/test/resources/ApisUsedTest/multipleInserts/after3.adoc
new file mode 100644
index 0000000..906b6ff
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/multipleInserts/after3.adoc
@@ -0,0 +1,232 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/EntityManager.html[jakarta.persistence.EntityManager]
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Id.html[jakarta.persistence.Id]
diff --git a/src/test/resources/ApisUsedTest/multipleInserts/before.adoc b/src/test/resources/ApisUsedTest/multipleInserts/before.adoc
new file mode 100644
index 0000000..5a86e09
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/multipleInserts/before.adoc
@@ -0,0 +1,226 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
diff --git a/src/test/resources/ApisUsedTest/noDuplicates/after.adoc b/src/test/resources/ApisUsedTest/noDuplicates/after.adoc
new file mode 100644
index 0000000..f83a09d
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/noDuplicates/after.adoc
@@ -0,0 +1,230 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
+
+= APIs Used
+
+- link:../../../jakartaee-9.0/javadoc/jakarta/persistence/Entity.html[jakarta.persistence.Entity]
diff --git a/src/test/resources/ApisUsedTest/noDuplicates/before.adoc b/src/test/resources/ApisUsedTest/noDuplicates/before.adoc
new file mode 100644
index 0000000..5a86e09
--- /dev/null
+++ b/src/test/resources/ApisUsedTest/noDuplicates/before.adoc
@@ -0,0 +1,226 @@
+= Injeção de Entitymanager
+:index-group: JPA
+:jbake-type: page
+:jbake-status: published
+
+Este exemplo mostra o uso de `@PersistenceContext` para ter um `EntityManager` com um contexto de persistência `EXTENDED` injetado em um `@Stateful bean`. Um bean JPA `@ Entity` é usado com o `EntityManager` para criar, persistir e mesclar dados em um banco de dados.
+
+== Criando a entidade JPA
+
+A própria entidade é simplesmente um pote anotado com `@Entity`. Criamos um chamado `Movie`, que podemos usar para armazenar registros de filmes.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.persistence.Entity;
+
+@Entity
+public class Movie {
+
+    @Id @GeneratedValue
+    private long id;
+
+    private String director;
+    private String title;
+    private int year;
+
+    public Movie() {
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public Movie(String director, String title, int year) {
+        this.director = director;
+        this.title = title;
+        this.year = year;
+    }
+
+    public String getDirector() {
+        return director;
+    }
+
+    public void setDirector(String director) {
+        this.director = director;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+}
+----
+
+== Configure o EntityManager por meio de um arquivo persistence.xml
+
+A entidade `Movie` acima pode ser criada, removida, atualizada ou excluída através de um objeto` EntityManager`.
+O próprio `EntityManager` é configurado através de um arquivo `META-INF/persistence.xml` que é colocado no mesmo jar que a entidade `Movie`.
+
+[source,xml,numbered]
+----
+<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
+
+  <persistence-unit name="movie-unit">
+    <jta-data-source>movieDatabase</jta-data-source>
+    <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+    <class>org.superbiz.injection.jpa.Movie</class>
+
+    <properties>
+      <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+    </properties>
+  </persistence-unit>
+</persistence>
+----
+
+Observe que a entidade `Movie` é listada através de um elemento `<class>`. Isso não é necessário, mas pode ajudar no teste ou quando a classe `Movie` estiver localizada em um jar diferente do jar que contém o arquivo `persistence.xml`.
+
+==Injeção via @PersistenceContext
+
+O próprio `EntityManager` é criado pelo contêiner usando as informações no `persistence.xml`, portanto, para usá-lo em tempo de execução, basta solicitar que ele seja injetado em um de nossos componentes. Fazemos isso via `@PersistenceContext`
+
+A anotação `@PersistenceContext` pode ser usada em qualquer bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter ou JSF ManagedBean. Se você não usar um EJB, precisará usar um `UserTransaction` para iniciar e confirmar transações manualmente. É necessária uma transação para que qualquer um dos métodos de criação, atualização ou exclusão do EntityManager funcione.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import jakarta.ejb.Stateful;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.PersistenceContextType;
+import jakarta.persistence.Query;
+import java.util.List;
+
+@Stateful
+public class Movies {
+
+    @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+    private EntityManager entityManager;
+
+    public void addMovie(Movie movie) throws Exception {
+        entityManager.persist(movie);
+    }
+
+    public void deleteMovie(Movie movie) throws Exception {
+        entityManager.remove(movie);
+    }
+
+    public List<Movie> getMovies() throws Exception {
+        Query query = entityManager.createQuery("SELECT m from Movie as m");
+        return query.getResultList();
+    }
+}
+----
+
+Este `EntityManager` específico é injetado como um contexto de persistência `EXTENDED`, o que significa simplesmente que o `EntityManager` é criado quando o bean `@Stateful` é criado e destruído quando o bean `@Stateful` é destruído. Simplificando, os dados no `EntityManager` são armazenados em cache durante o tempo de vida do bean `@ Stateful`.
+
+O uso de contextos de persistência `EXTENDED` está *apenas* disponível para beans `@Stateful`. Consulte o link: ../../jpa-concepts.html [Conceitos da JPA] para obter uma explicação de alto nível sobre o que realmente é um "contexto de persistência" e como é significativo para a JPA.
+
+== MoviesTest
+
+Testar o JPA é bastante fácil, podemos simplesmente usar a API `EJBContainer` para criar um contêiner em nosso caso de teste.
+
+[source,java,numbered]
+----
+package org.superbiz.injection.jpa;
+
+import junit.framework.TestCase;
+
+import jakarta.ejb.embeddable.EJBContainer;
+import javax.naming.Context;
+import java.util.List;
+import java.util.Properties;
+
+public class MoviesTest extends TestCase {
+
+    public void test() throws Exception {
+
+        final Properties p = new Properties();
+        p.put("movieDatabase", "new://Resource?type=DataSource");
+        p.put("movieDatabase.JdbcDriver", "org.hsqldb.jdbcDriver");
+        p.put("movieDatabase.JdbcUrl", "jdbc:hsqldb:mem:moviedb");
+
+        final Context context = EJBContainer.createEJBContainer(p).getContext();
+
+        Movies movies = (Movies) context.lookup("java:global/injection-of-entitymanager/Movies");
+
+        movies.addMovie(new Movie("Quentin Tarantino", "Reservoir Dogs", 1992));
+        movies.addMovie(new Movie("Joel Coen", "Fargo", 1996));
+        movies.addMovie(new Movie("Joel Coen", "The Big Lebowski", 1998));
+
+        List<Movie> list = movies.getMovies();
+        assertEquals("List.size()", 3, list.size());
+
+        for (Movie movie : list) {
+            movies.deleteMovie(movie);
+        }
+
+        assertEquals("Movies.getMovies()", 0, movies.getMovies().size());
+    }
+}
+----
+
+= Executando
+
+Quando executamos nosso caso de teste, devemos ver uma saída semelhante à seguinte.
+
+[source,console]
+----
+-------------------------------------------------------
+ T E S T S
+-------------------------------------------------------
+Running org.superbiz.injection.jpa.MoviesTest
+Apache OpenEJB 4.0.0-beta-1    build: 20111002-04:06
+http://tomee.apache.org/
+INFO - openejb.home = /Users/dblevins/examples/injection-of-entitymanager
+INFO - openejb.base = /Users/dblevins/examples/injection-of-entitymanager
+INFO - Using 'jakarta.ejb.embeddable.EJBContainer=true'
+INFO - Configuring Service(id=Default Security Service, type=SecurityService, provider-id=Default Security Service)
+INFO - Configuring Service(id=Default Transaction Manager, type=TransactionManager, provider-id=Default Transaction Manager)
+INFO - Configuring Service(id=movieDatabase, type=Resource, provider-id=Default JDBC Database)
+INFO - Found EjbModule in classpath: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Beginning load: /Users/dblevins/examples/injection-of-entitymanager/target/classes
+INFO - Configuring enterprise application: /Users/dblevins/examples/injection-of-entitymanager
+INFO - Configuring Service(id=Default Stateful Container, type=Container, provider-id=Default Stateful Container)
+INFO - Auto-creating a container for bean Movies: Container(type=STATEFUL, id=Default Stateful Container)
+INFO - Configuring Service(id=Default Managed Container, type=Container, provider-id=Default Managed Container)
+INFO - Auto-creating a container for bean org.superbiz.injection.jpa.MoviesTest: Container(type=MANAGED, id=Default Managed Container)
+INFO - Configuring PersistenceUnit(name=movie-unit)
+INFO - Auto-creating a Resource with id 'movieDatabaseNonJta' of type 'DataSource for 'movie-unit'.
+INFO - Configuring Service(id=movieDatabaseNonJta, type=Resource, provider-id=movieDatabase)
+INFO - Adjusting PersistenceUnit movie-unit <non-jta-data-source> to Resource ID 'movieDatabaseNonJta' from 'movieDatabaseUnmanaged'
+INFO - Enterprise application "/Users/dblevins/examples/injection-of-entitymanager" loaded.
+INFO - Assembling app: /Users/dblevins/examples/injection-of-entitymanager
+INFO - PersistenceUnit(name=movie-unit, provider=org.apache.openjpa.persistence.PersistenceProviderImpl) - provider time 462ms
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies!org.superbiz.injection.jpa.Movies")
+INFO - Jndi(name="java:global/injection-of-entitymanager/Movies")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest!org.superbiz.injection.jpa.MoviesTest")
+INFO - Jndi(name="java:global/EjbModule1461341140/org.superbiz.injection.jpa.MoviesTest")
+INFO - Created Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Created Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Started Ejb(deployment-id=Movies, ejb-name=Movies, container=Default Stateful Container)
+INFO - Started Ejb(deployment-id=org.superbiz.injection.jpa.MoviesTest, ejb-name=org.superbiz.injection.jpa.MoviesTest, container=Default Managed Container)
+INFO - Deployed Application(path=/Users/dblevins/examples/injection-of-entitymanager)
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.301 sec
+
+Results :
+
+Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+----
diff --git a/src/test/resources/SeeLinksTest/insertHref/after.java b/src/test/resources/ExampleLinksTest/finalClass/after.java
similarity index 93%
copy from src/test/resources/SeeLinksTest/insertHref/after.java
copy to src/test/resources/ExampleLinksTest/finalClass/after.java
index 75f3b52..e91e524 100644
--- a/src/test/resources/SeeLinksTest/insertHref/after.java
+++ b/src/test/resources/ExampleLinksTest/finalClass/after.java
@@ -27,9 +27,9 @@
  * entity class.
  *
  * @since Java Persistence 1.0
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
  */
-public interface Entity {
+final public interface Entity {
 
         /**
          * (Optional) The entity name. Defaults to the unqualified
diff --git a/src/test/resources/SeeLinksTest/insertHref/after.java b/src/test/resources/ExampleLinksTest/finalClass/before.java
similarity index 93%
copy from src/test/resources/SeeLinksTest/insertHref/after.java
copy to src/test/resources/ExampleLinksTest/finalClass/before.java
index 75f3b52..eeee40d 100644
--- a/src/test/resources/SeeLinksTest/insertHref/after.java
+++ b/src/test/resources/ExampleLinksTest/finalClass/before.java
@@ -27,9 +27,8 @@
  * entity class.
  *
  * @since Java Persistence 1.0
- * @see <a href="http://example.org/orange.html">Orange Example</a>
  */
-public interface Entity {
+final public interface Entity {
 
         /**
          * (Optional) The entity name. Defaults to the unqualified
diff --git a/src/test/resources/SeeLinksTest/hasAnnotations/after.java b/src/test/resources/ExampleLinksTest/hasAnnotations/after.java
similarity index 95%
rename from src/test/resources/SeeLinksTest/hasAnnotations/after.java
rename to src/test/resources/ExampleLinksTest/hasAnnotations/after.java
index f5a3706..ceefe62 100644
--- a/src/test/resources/SeeLinksTest/hasAnnotations/after.java
+++ b/src/test/resources/ExampleLinksTest/hasAnnotations/after.java
@@ -23,7 +23,7 @@
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
  */
 @Documented
 @Target(TYPE)
diff --git a/src/test/resources/SeeLinksTest/hasAnnotations/before.java b/src/test/resources/ExampleLinksTest/hasAnnotations/before.java
similarity index 100%
rename from src/test/resources/SeeLinksTest/hasAnnotations/before.java
rename to src/test/resources/ExampleLinksTest/hasAnnotations/before.java
diff --git a/src/test/resources/SeeLinksTest/insertHref/after.java b/src/test/resources/ExampleLinksTest/insertHref/after.java
similarity index 95%
rename from src/test/resources/SeeLinksTest/insertHref/after.java
rename to src/test/resources/ExampleLinksTest/insertHref/after.java
index 75f3b52..ef26259 100644
--- a/src/test/resources/SeeLinksTest/insertHref/after.java
+++ b/src/test/resources/ExampleLinksTest/insertHref/after.java
@@ -27,7 +27,7 @@
  * entity class.
  *
  * @since Java Persistence 1.0
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
  */
 public interface Entity {
 
diff --git a/src/test/resources/SeeLinksTest/insertHref/before.java b/src/test/resources/ExampleLinksTest/insertHref/before.java
similarity index 100%
rename from src/test/resources/SeeLinksTest/insertHref/before.java
rename to src/test/resources/ExampleLinksTest/insertHref/before.java
diff --git a/src/test/resources/SeeLinksTest/multipleInserts/after1.java b/src/test/resources/ExampleLinksTest/multipleInserts/after1.java
similarity index 92%
rename from src/test/resources/SeeLinksTest/multipleInserts/after1.java
rename to src/test/resources/ExampleLinksTest/multipleInserts/after1.java
index 13ae94a..0aa811d 100644
--- a/src/test/resources/SeeLinksTest/multipleInserts/after1.java
+++ b/src/test/resources/ExampleLinksTest/multipleInserts/after1.java
@@ -17,7 +17,7 @@
 package javax.persistence;
 
 /**
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
  */
 public enum Shapes {
     CIRCLE,
diff --git a/src/test/resources/SeeLinksTest/multipleInserts/after1.java b/src/test/resources/ExampleLinksTest/multipleInserts/after2.java
similarity index 86%
copy from src/test/resources/SeeLinksTest/multipleInserts/after1.java
copy to src/test/resources/ExampleLinksTest/multipleInserts/after2.java
index 13ae94a..7471d5e 100644
--- a/src/test/resources/SeeLinksTest/multipleInserts/after1.java
+++ b/src/test/resources/ExampleLinksTest/multipleInserts/after2.java
@@ -17,7 +17,8 @@
 package javax.persistence;
 
 /**
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/red.html">Red Sample</a>
  */
 public enum Shapes {
     CIRCLE,
diff --git a/src/test/resources/SeeLinksTest/multipleInserts/after1.java b/src/test/resources/ExampleLinksTest/multipleInserts/after3.java
similarity index 81%
copy from src/test/resources/SeeLinksTest/multipleInserts/after1.java
copy to src/test/resources/ExampleLinksTest/multipleInserts/after3.java
index 13ae94a..5eb5e0d 100644
--- a/src/test/resources/SeeLinksTest/multipleInserts/after1.java
+++ b/src/test/resources/ExampleLinksTest/multipleInserts/after3.java
@@ -17,7 +17,9 @@
 package javax.persistence;
 
 /**
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/red.html">Red Sample</a>
+ * @example <a href="http://example.org/yellow.html">yellow</a>
  */
 public enum Shapes {
     CIRCLE,
diff --git a/src/test/resources/SeeLinksTest/multipleInserts/before.java b/src/test/resources/ExampleLinksTest/multipleInserts/before.java
similarity index 100%
rename from src/test/resources/SeeLinksTest/multipleInserts/before.java
rename to src/test/resources/ExampleLinksTest/multipleInserts/before.java
diff --git a/src/test/resources/SeeLinksTest/insertHref/after.java b/src/test/resources/ExampleLinksTest/noDuplicates/after.java
similarity index 95%
copy from src/test/resources/SeeLinksTest/insertHref/after.java
copy to src/test/resources/ExampleLinksTest/noDuplicates/after.java
index 75f3b52..ef26259 100644
--- a/src/test/resources/SeeLinksTest/insertHref/after.java
+++ b/src/test/resources/ExampleLinksTest/noDuplicates/after.java
@@ -27,7 +27,7 @@
  * entity class.
  *
  * @since Java Persistence 1.0
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
  */
 public interface Entity {
 
diff --git a/src/test/resources/SeeLinksTest/noDuplicates/before.java b/src/test/resources/ExampleLinksTest/noDuplicates/before.java
similarity index 100%
rename from src/test/resources/SeeLinksTest/noDuplicates/before.java
rename to src/test/resources/ExampleLinksTest/noDuplicates/before.java
diff --git a/src/test/resources/SeeLinksTest/noJavadoc/after.java b/src/test/resources/ExampleLinksTest/noJavadoc/after.java
similarity index 93%
rename from src/test/resources/SeeLinksTest/noJavadoc/after.java
rename to src/test/resources/ExampleLinksTest/noJavadoc/after.java
index da7abb7..9ed617c 100644
--- a/src/test/resources/SeeLinksTest/noJavadoc/after.java
+++ b/src/test/resources/ExampleLinksTest/noJavadoc/after.java
@@ -17,7 +17,7 @@
 package javax.persistence;
 
 /**
- * @see <a href="http://example.org/orange.html">Orange Example</a>
+ * @example <a href="http://example.org/orange.html">Orange Example</a>
  */
 public @interface Entity {
 
diff --git a/src/test/resources/SeeLinksTest/noJavadoc/before.java b/src/test/resources/ExampleLinksTest/noJavadoc/before.java
similarity index 100%
rename from src/test/resources/SeeLinksTest/noJavadoc/before.java
rename to src/test/resources/ExampleLinksTest/noJavadoc/before.java
diff --git a/src/test/resources/SeeLinksTest/multipleInserts/after2.java b/src/test/resources/SeeLinksTest/multipleInserts/after2.java
deleted file mode 100644
index d673789..0000000
--- a/src/test/resources/SeeLinksTest/multipleInserts/after2.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 javax.persistence;
-
-/**
- * @see <a href="http://example.org/orange.html">Orange Example</a>
- * @see <a href="http://example.org/red.html">Red Sample</a>
- */
-public enum Shapes {
-    CIRCLE,
-    TRIANGLE,
-    SQUARE
-}
\ No newline at end of file
diff --git a/src/test/resources/SeeLinksTest/multipleInserts/after3.java b/src/test/resources/SeeLinksTest/multipleInserts/after3.java
deleted file mode 100644
index a7f36e1..0000000
--- a/src/test/resources/SeeLinksTest/multipleInserts/after3.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 javax.persistence;
-
-/**
- * @see <a href="http://example.org/orange.html">Orange Example</a>
- * @see <a href="http://example.org/red.html">Red Sample</a>
- * @see <a href="http://example.org/yellow.html">yellow</a>
- */
-public enum Shapes {
-    CIRCLE,
-    TRIANGLE,
-    SQUARE
-}
\ No newline at end of file
diff --git a/src/test/resources/SeeLinksTest/noDuplicates/after.java b/src/test/resources/SeeLinksTest/noDuplicates/after.java
deleted file mode 100644
index 75f3b52..0000000
--- a/src/test/resources/SeeLinksTest/noDuplicates/after.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 javax.persistence;
-
-import java.lang.annotation.Target;
-import java.lang.annotation.Retention;
-import java.lang.annotation.Documented;
-import static java.lang.annotation.ElementType.TYPE;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-/**
- * Specifies that the class is an entity. This annotation is applied to the
- * entity class.
- *
- * @since Java Persistence 1.0
- * @see <a href="http://example.org/orange.html">Orange Example</a>
- */
-public interface Entity {
-
-        /**
-         * (Optional) The entity name. Defaults to the unqualified
-         * name of the entity class. This name is used to refer to the
-         * entity in queries. The name must not be a reserved literal
-         * in the Java Persistence query language.
-         */
-        String name();
-}
\ No newline at end of file