From be2d3dd0b93e1aed183e86b57867d26cea646ed9 Mon Sep 17 00:00:00 2001 From: "Kevin S. Clarke" Date: Wed, 3 Jul 2024 22:31:12 -0400 Subject: [PATCH] Add tests --- .../annotations/AssessingAnnotationTest.java | 136 ++++++++++++++++ .../BookmarkingAnnotationTest.java | 138 ++++++++++++++++ .../ClassifyingAnnotationTest.java | 138 ++++++++++++++++ .../annotations/CommentingAnnotationTest.java | 143 +++++++++++++---- .../annotations/DescribingAnnotationTest.java | 136 ++++++++++++++++ .../v3/annotations/EditingAnnotationTest.java | 136 ++++++++++++++++ .../HighlightingAnnotationTest.java | 138 ++++++++++++++++ .../IdentifyingAnnotationTest.java | 138 ++++++++++++++++ .../v3/annotations/LinkingAnnotationTest.java | 136 ++++++++++++++++ .../annotations/ModeratingAnnotationTest.java | 136 ++++++++++++++++ .../QuestioningAnnotationTest.java | 138 ++++++++++++++++ .../annotations/ReplyingAnnotationTest.java | 136 ++++++++++++++++ .../v3/annotations/TaggingAnnotationTest.java | 142 +++++++++++++---- .../v3/exts/geo/BoundingBoxTest.java | 150 ++++++++++++++++++ .../iiif/presentation/v3/utils/TestUtils.java | 17 ++ 15 files changed, 1899 insertions(+), 59 deletions(-) create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/AssessingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/BookmarkingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ClassifyingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/DescribingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/EditingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/HighlightingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/IdentifyingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/LinkingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ModeratingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/QuestioningAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ReplyingAnnotationTest.java create mode 100644 src/test/java/info/freelibrary/iiif/presentation/v3/exts/geo/BoundingBoxTest.java diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/AssessingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/AssessingAnnotationTest.java new file mode 100644 index 00000000..00bd18bf --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/AssessingAnnotationTest.java @@ -0,0 +1,136 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code AssesssingAnnotation}. + */ +public class AssessingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(Minter)}. + */ + @Test + public final void testAssessingAnnotationMinter() { + assertTrue(new AssessingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testAssessingAnnotationMinterCanvasResourceOfC() { + assertTrue(new AssessingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testAssessingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new AssessingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testAssessingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new AssessingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testAssessingAnnotationStringCanvasResourceOfC() { + assertTrue( + new AssessingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testAssessingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new AssessingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testAssessingAnnotationStringCanvasResourceOfCString() { + assertTrue(new AssessingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(String, Manifest)}. + */ + @Test + public final void testAssessingAnnotationStringManifest() { + assertTrue(new AssessingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#AssessingAnnotation(String, Target)}. + */ + @Test + public final void testAssessingAnnotationStringTarget() { + assertTrue(new AssessingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link AssessingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new AssessingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new AssessingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.BOOKMARKING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/BookmarkingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/BookmarkingAnnotationTest.java new file mode 100644 index 00000000..ee47b3d0 --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/BookmarkingAnnotationTest.java @@ -0,0 +1,138 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code BookmarkingAnnotation}. + */ +public class BookmarkingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link BookmarkingAnnotation#BookmarkingAnnotation(Minter)}. + */ + @Test + public final void testBookmarkingAnnotationMinter() { + assertTrue(new BookmarkingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#BookmarkingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testBookmarkingAnnotationMinterCanvasResourceOfC() { + assertTrue(new BookmarkingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link BookmarkingAnnotation#BookmarkingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testBookmarkingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new BookmarkingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#BookmarkingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testBookmarkingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new BookmarkingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#BookmarkingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testBookmarkingAnnotationStringCanvasResourceOfC() { + assertTrue(new BookmarkingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link BookmarkingAnnotation#BookmarkingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testBookmarkingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new BookmarkingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#BookmarkingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testBookmarkingAnnotationStringCanvasResourceOfCString() { + assertTrue(new BookmarkingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#BookmarkingAnnotation(String, Manifest)}. + */ + @Test + public final void testBookmarkingAnnotationStringManifest() { + assertTrue(new BookmarkingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#BookmarkingAnnotation(String, Target)}. + */ + @Test + public final void testBookmarkingAnnotationStringTarget() { + assertTrue(new BookmarkingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new BookmarkingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.BOOKMARKING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link BookmarkingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new BookmarkingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ClassifyingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ClassifyingAnnotationTest.java new file mode 100644 index 00000000..68382dff --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ClassifyingAnnotationTest.java @@ -0,0 +1,138 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code ClassifyingAnnotation}. + */ +public class ClassifyingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link ClassifyingAnnotation#ClassifyingAnnotation(Minter)}. + */ + @Test + public final void testClassifyingAnnotationMinter() { + assertTrue(new ClassifyingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#ClassifyingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testClassifyingAnnotationMinterCanvasResourceOfC() { + assertTrue(new ClassifyingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link ClassifyingAnnotation#ClassifyingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testClassifyingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new ClassifyingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#ClassifyingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testClassifyingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new ClassifyingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#ClassifyingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testClassifyingAnnotationStringCanvasResourceOfC() { + assertTrue(new ClassifyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link ClassifyingAnnotation#ClassifyingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testClassifyingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new ClassifyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#ClassifyingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testClassifyingAnnotationStringCanvasResourceOfCString() { + assertTrue(new ClassifyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#ClassifyingAnnotation(String, Manifest)}. + */ + @Test + public final void testClassifyingAnnotationStringManifest() { + assertTrue(new ClassifyingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#ClassifyingAnnotation(String, Target)}. + */ + @Test + public final void testClassifyingAnnotationStringTarget() { + assertTrue(new ClassifyingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new ClassifyingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.CLASSIFYING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ClassifyingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new ClassifyingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/CommentingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/CommentingAnnotationTest.java index d153dc8d..6e579a26 100644 --- a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/CommentingAnnotationTest.java +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/CommentingAnnotationTest.java @@ -1,53 +1,136 @@ package info.freelibrary.iiif.presentation.v3.annotations; -import static org.junit.Assert.assertEquals; - -import java.io.File; -import java.io.IOException; -import java.nio.charset.StandardCharsets; +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; +import org.junit.Before; import org.junit.Test; -import com.fasterxml.jackson.core.JsonProcessingException; - -import info.freelibrary.util.StringUtils; - import info.freelibrary.iiif.presentation.v3.Canvas; -import info.freelibrary.iiif.presentation.v3.TextualBody; -import info.freelibrary.iiif.presentation.v3.properties.MediaType; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; /** - * Tests of {@code CommentingAnnotation}. + * Tests {@code CommentingAnnotation}. */ public class CommentingAnnotationTest { - /** An annotation ID. */ - private static final String ANNO_ID = - "https://iiif.io/api/cookbook/recipe/0266-full-canvas-annotation/canvas-1/annopage-2/anno-1"; + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; - /** A canvas ID. */ - private static final String CANVAS_ID = "https://iiif.io/api/cookbook/recipe/0266-full-canvas-annotation/canvas-1"; + /** A minter to use in testing. */ + private Minter myMinter; - /** An annotation that can be used in testing. */ - private static final File JSON_FILE = new File("src/test/resources/json/commenting-annotation.json"); + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } /** - * Tests the {@code CommentingAnnotation#toString()}. - * - * @throws JsonProcessingException If there is trouble serializing a CommentingAnnotation - * @throws IOException If there is trouble reading the test JSON annotation file + * Test method for {@link CommentingAnnotation#CommentingAnnotation(Minter)}. */ @Test - public final void testToString() throws IOException { - final String expected = StringUtils.read(JSON_FILE, StandardCharsets.UTF_8); - final CommentingAnnotation commenting = new CommentingAnnotation(ANNO_ID, new Canvas(CANVAS_ID)); - final TextualBody body = new TextualBody(); + public final void testCommentingAnnotationMinter() { + assertTrue(new CommentingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } - body.setLanguage("de").setFormat(MediaType.TEXT_PLAIN).setValue("Göttinger Marktplatz mit Gänseliesel Brunnen"); - commenting.setBody(body); + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testCommentingAnnotationMinterCanvasResourceOfC() { + assertTrue(new CommentingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } - assertEquals(expected, commenting.toString()); + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testCommentingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new CommentingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); } + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testCommentingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new CommentingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testCommentingAnnotationStringCanvasResourceOfC() { + assertTrue(new CommentingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testCommentingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new CommentingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testCommentingAnnotationStringCanvasResourceOfCString() { + assertTrue(new CommentingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(String, Manifest)}. + */ + @Test + public final void testCommentingAnnotationStringManifest() { + assertTrue(new CommentingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link CommentingAnnotation#CommentingAnnotation(String, Target)}. + */ + @Test + public final void testCommentingAnnotationStringTarget() { + assertTrue(new CommentingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link CommentingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new CommentingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.COMMENTING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link CommentingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new CommentingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } } diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/DescribingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/DescribingAnnotationTest.java new file mode 100644 index 00000000..1b96754d --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/DescribingAnnotationTest.java @@ -0,0 +1,136 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code DescribingAnnotation}. + */ +public class DescribingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(Minter)}. + */ + @Test + public final void testDescribingAnnotationMinter() { + assertTrue(new DescribingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testDescribingAnnotationMinterCanvasResourceOfC() { + assertTrue(new DescribingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testDescribingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new DescribingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testDescribingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new DescribingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testDescribingAnnotationStringCanvasResourceOfC() { + assertTrue(new DescribingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testDescribingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new DescribingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testDescribingAnnotationStringCanvasResourceOfCString() { + assertTrue(new DescribingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(String, Manifest)}. + */ + @Test + public final void testDescribingAnnotationStringManifest() { + assertTrue(new DescribingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#DescribingAnnotation(String, Target)}. + */ + @Test + public final void testDescribingAnnotationStringTarget() { + assertTrue(new DescribingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new DescribingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.DESCRIBING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link DescribingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new DescribingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/EditingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/EditingAnnotationTest.java new file mode 100644 index 00000000..62988274 --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/EditingAnnotationTest.java @@ -0,0 +1,136 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code EditingAnnotation}. + */ +public class EditingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(Minter)}. + */ + @Test + public final void testEditingAnnotationMinter() { + assertTrue(new EditingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testEditingAnnotationMinterCanvasResourceOfC() { + assertTrue(new EditingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testEditingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new EditingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testEditingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new EditingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testEditingAnnotationStringCanvasResourceOfC() { + assertTrue( + new EditingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testEditingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new EditingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testEditingAnnotationStringCanvasResourceOfCString() { + assertTrue(new EditingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(String, Manifest)}. + */ + @Test + public final void testEditingAnnotationStringManifest() { + assertTrue(new EditingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#EditingAnnotation(String, Target)}. + */ + @Test + public final void testEditingAnnotationStringTarget() { + assertTrue(new EditingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new EditingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.EDITING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link EditingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new EditingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/HighlightingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/HighlightingAnnotationTest.java new file mode 100644 index 00000000..d40582ce --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/HighlightingAnnotationTest.java @@ -0,0 +1,138 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code HighlightingAnnotation}. + */ +public class HighlightingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link HighlightingAnnotation#HighlightingAnnotation(Minter)}. + */ + @Test + public final void testHighlightingAnnotationMinter() { + assertTrue(new HighlightingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#HighlightingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testHighlightingAnnotationMinterCanvasResourceOfC() { + assertTrue(new HighlightingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link HighlightingAnnotation#HighlightingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testHighlightingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new HighlightingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#HighlightingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testHighlightingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new HighlightingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#HighlightingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testHighlightingAnnotationStringCanvasResourceOfC() { + assertTrue(new HighlightingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link HighlightingAnnotation#HighlightingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testHighlightingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new HighlightingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#HighlightingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testHighlightingAnnotationStringCanvasResourceOfCString() { + assertTrue(new HighlightingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150") + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#HighlightingAnnotation(String, Manifest)}. + */ + @Test + public final void testHighlightingAnnotationStringManifest() { + assertTrue(new HighlightingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#HighlightingAnnotation(String, Target)}. + */ + @Test + public final void testHighlightingAnnotationStringTarget() { + assertTrue(new HighlightingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new HighlightingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.HIGHLIGHTING)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link HighlightingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new HighlightingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/IdentifyingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/IdentifyingAnnotationTest.java new file mode 100644 index 00000000..03c65c38 --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/IdentifyingAnnotationTest.java @@ -0,0 +1,138 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code IdentifyingAnnotation}. + */ +public class IdentifyingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link IdentifyingAnnotation#IdentifyingAnnotation(Minter)}. + */ + @Test + public final void testIdentifyingAnnotationMinter() { + assertTrue(new IdentifyingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#IdentifyingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testIdentifyingAnnotationMinterCanvasResourceOfC() { + assertTrue(new IdentifyingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link IdentifyingAnnotation#IdentifyingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testIdentifyingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new IdentifyingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#IdentifyingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testIdentifyingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new IdentifyingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#IdentifyingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testIdentifyingAnnotationStringCanvasResourceOfC() { + assertTrue(new IdentifyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link IdentifyingAnnotation#IdentifyingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testIdentifyingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new IdentifyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#IdentifyingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testIdentifyingAnnotationStringCanvasResourceOfCString() { + assertTrue(new IdentifyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#IdentifyingAnnotation(String, Manifest)}. + */ + @Test + public final void testIdentifyingAnnotationStringManifest() { + assertTrue(new IdentifyingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#IdentifyingAnnotation(String, Target)}. + */ + @Test + public final void testIdentifyingAnnotationStringTarget() { + assertTrue(new IdentifyingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new IdentifyingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.IDENTIFYING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link IdentifyingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new IdentifyingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/LinkingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/LinkingAnnotationTest.java new file mode 100644 index 00000000..75650bd7 --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/LinkingAnnotationTest.java @@ -0,0 +1,136 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code LinkingAnnotation}. + */ +public class LinkingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(Minter)}. + */ + @Test + public final void testLinkingAnnotationMinter() { + assertTrue(new LinkingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testLinkingAnnotationMinterCanvasResourceOfC() { + assertTrue(new LinkingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testLinkingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new LinkingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testLinkingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new LinkingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testLinkingAnnotationStringCanvasResourceOfC() { + assertTrue( + new LinkingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testLinkingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new LinkingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testLinkingAnnotationStringCanvasResourceOfCString() { + assertTrue(new LinkingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(String, Manifest)}. + */ + @Test + public final void testLinkingAnnotationStringManifest() { + assertTrue(new LinkingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#LinkingAnnotation(String, Target)}. + */ + @Test + public final void testLinkingAnnotationStringTarget() { + assertTrue(new LinkingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new LinkingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.LINKING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link LinkingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new LinkingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ModeratingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ModeratingAnnotationTest.java new file mode 100644 index 00000000..60529d8f --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ModeratingAnnotationTest.java @@ -0,0 +1,136 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code ModeratingAnnotation}. + */ +public class ModeratingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(Minter)}. + */ + @Test + public final void testModeratingAnnotationMinter() { + assertTrue(new ModeratingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testModeratingAnnotationMinterCanvasResourceOfC() { + assertTrue(new ModeratingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testModeratingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new ModeratingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testModeratingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new ModeratingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testModeratingAnnotationStringCanvasResourceOfC() { + assertTrue(new ModeratingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testModeratingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new ModeratingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testModeratingAnnotationStringCanvasResourceOfCString() { + assertTrue(new ModeratingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(String, Manifest)}. + */ + @Test + public final void testModeratingAnnotationStringManifest() { + assertTrue(new ModeratingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#ModeratingAnnotation(String, Target)}. + */ + @Test + public final void testModeratingAnnotationStringTarget() { + assertTrue(new ModeratingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new ModeratingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.MODERATING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ModeratingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new ModeratingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/QuestioningAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/QuestioningAnnotationTest.java new file mode 100644 index 00000000..3861df23 --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/QuestioningAnnotationTest.java @@ -0,0 +1,138 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code QuestioningAnnotation}. + */ +public class QuestioningAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link QuestioningAnnotation#QuestioningAnnotation(Minter)}. + */ + @Test + public final void testQuestioningAnnotationMinter() { + assertTrue(new QuestioningAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#QuestioningAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testQuestioningAnnotationMinterCanvasResourceOfC() { + assertTrue(new QuestioningAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link QuestioningAnnotation#QuestioningAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testQuestioningAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new QuestioningAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#QuestioningAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testQuestioningAnnotationMinterCanvasResourceOfCString() { + assertTrue(new QuestioningAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#QuestioningAnnotation(String, CanvasResource)}. + */ + @Test + public final void testQuestioningAnnotationStringCanvasResourceOfC() { + assertTrue(new QuestioningAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for + * {@link QuestioningAnnotation#QuestioningAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testQuestioningAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new QuestioningAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#QuestioningAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testQuestioningAnnotationStringCanvasResourceOfCString() { + assertTrue(new QuestioningAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#QuestioningAnnotation(String, Manifest)}. + */ + @Test + public final void testQuestioningAnnotationStringManifest() { + assertTrue(new QuestioningAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#QuestioningAnnotation(String, Target)}. + */ + @Test + public final void testQuestioningAnnotationStringTarget() { + assertTrue(new QuestioningAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new QuestioningAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.QUESTIONING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link QuestioningAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new QuestioningAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ReplyingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ReplyingAnnotationTest.java new file mode 100644 index 00000000..a7957bd1 --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/ReplyingAnnotationTest.java @@ -0,0 +1,136 @@ + +package info.freelibrary.iiif.presentation.v3.annotations; + +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; + +import org.junit.Before; +import org.junit.Test; + +import info.freelibrary.iiif.presentation.v3.Canvas; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; + +/** + * Tests {@code ReplyingAnnotation}. + */ +public class ReplyingAnnotationTest { + + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; + + /** A minter to use in testing. */ + private Minter myMinter; + + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(Minter)}. + */ + @Test + public final void testReplyingAnnotationMinter() { + assertTrue(new ReplyingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testReplyingAnnotationMinterCanvasResourceOfC() { + assertTrue(new ReplyingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testReplyingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new ReplyingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testReplyingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new ReplyingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testReplyingAnnotationStringCanvasResourceOfC() { + assertTrue( + new ReplyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testReplyingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new ReplyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testReplyingAnnotationStringCanvasResourceOfCString() { + assertTrue(new ReplyingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(String, Manifest)}. + */ + @Test + public final void testReplyingAnnotationStringManifest() { + assertTrue(new ReplyingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#ReplyingAnnotation(String, Target)}. + */ + @Test + public final void testReplyingAnnotationStringTarget() { + assertTrue(new ReplyingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#setMotivation(Motivation)}. + */ + @Test + public final void testSetMotivationMotivation() { + assertTrue(new ReplyingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.REPLYING)).getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link ReplyingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new ReplyingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/TaggingAnnotationTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/TaggingAnnotationTest.java index f2fde986..f15191a8 100644 --- a/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/TaggingAnnotationTest.java +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/annotations/TaggingAnnotationTest.java @@ -1,52 +1,136 @@ package info.freelibrary.iiif.presentation.v3.annotations; -import static org.junit.Assert.assertEquals; - -import java.io.File; -import java.io.IOException; -import java.nio.charset.StandardCharsets; +import static info.freelibrary.iiif.presentation.v3.utils.TestUtils.getRandom; +import static org.junit.Assert.assertTrue; +import org.junit.Before; import org.junit.Test; -import com.fasterxml.jackson.core.JsonProcessingException; - -import info.freelibrary.util.StringUtils; - import info.freelibrary.iiif.presentation.v3.Canvas; -import info.freelibrary.iiif.presentation.v3.TextualBody; -import info.freelibrary.iiif.presentation.v3.properties.MediaType; +import info.freelibrary.iiif.presentation.v3.CanvasResource; +import info.freelibrary.iiif.presentation.v3.Manifest; +import info.freelibrary.iiif.presentation.v3.ids.Minter; +import info.freelibrary.iiif.presentation.v3.ids.MinterFactory; +import info.freelibrary.iiif.presentation.v3.properties.Label; +import info.freelibrary.iiif.presentation.v3.properties.selectors.MediaFragmentSelector; /** - * Tests of {@code TaggingAnnotation}. + * Tests {@code TaggingAnnotation}. */ public class TaggingAnnotationTest { - /** An annotation ID. */ - private static final String ANNO_ID = "https://iiif.io/api/cookbook/recipe/0021-tagging/annotation/p0002-tag"; + /** A persistent ID to use in testing. */ + private static final String ID = "https://example.com/asdf"; + + /** A pattern to use when testing IDs. */ + private static final String ID_PATTERN = "https://example.com/asdf/annotations/anno-"; - /** A canvas ID. */ - private static final String CANVAS_ID = "https://iiif.io/api/cookbook/recipe/0021-tagging/canvas/p1"; + /** A minter to use in testing. */ + private Minter myMinter; - /** An annotation that can be used in testing. */ - private static final File JSON_FILE = new File("src/test/resources/json/tagging-annotation.json"); + /** + * Sets up the test environment. + */ + @Before + public final void setUp() { + myMinter = MinterFactory.getMinter(new Manifest(ID, new Label("A label"))); + } /** - * Tests the {@code TaggingAnnotation#toString()}. - * - * @throws JsonProcessingException If there is trouble serializing a TaggingAnnotation - * @throws IOException If there is trouble reading the test JSON annotation file + * Test method for {@link TaggingAnnotation#setMotivation(Motivation)}. */ @Test - public final void testToString() throws IOException { - final String expected = StringUtils.read(JSON_FILE, StandardCharsets.UTF_8); - final TaggingAnnotation tagging = new TaggingAnnotation(ANNO_ID, new Canvas(CANVAS_ID)); - final TextualBody body = new TextualBody(); + public final void testSetMotivationMotivation() { + assertTrue(new TaggingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.TAGGING)).getID() + .startsWith(ID_PATTERN)); + } - body.setLanguage("de").setFormat(MediaType.TEXT_PLAIN).setValue("Gänseliesel-Brunnen"); - tagging.setBody(body); + /** + * Test method for {@link TaggingAnnotation#setMotivation(Motivation)}. + */ + @Test(expected = IllegalArgumentException.class) + public final void testSetMotivationMotivationBad() { + assertTrue(new TaggingAnnotation(myMinter).setMotivation(Motivation.fromLabel(Purpose.ASSESSING)).getID() + .startsWith(ID_PATTERN)); + } - assertEquals(expected, tagging.toString()); + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(Minter)}. + */ + @Test + public final void testTaggingAnnotationMinter() { + assertTrue(new TaggingAnnotation(myMinter).getID().startsWith(ID_PATTERN)); } + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(Minter, CanvasResource)}. + */ + @Test + public final void testTaggingAnnotationMinterCanvasResourceOfC() { + assertTrue(new TaggingAnnotation(myMinter, new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(Minter, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testTaggingAnnotationMinterCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new TaggingAnnotation(myMinter, new Canvas(myMinter), new MediaFragmentSelector(0, 0, 100, 100)) + .getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(Minter, CanvasResource, String)}. + */ + @Test + public final void testTaggingAnnotationMinterCanvasResourceOfCString() { + assertTrue(new TaggingAnnotation(myMinter, new Canvas(myMinter), "xywh=0,0,100,100").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(String, CanvasResource)}. + */ + @Test + public final void testTaggingAnnotationStringCanvasResourceOfC() { + assertTrue( + new TaggingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter)).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(String, CanvasResource, MediaFragmentSelector)}. + */ + @Test + public final void testTaggingAnnotationStringCanvasResourceOfCMediaFragmentSelector() { + assertTrue(new TaggingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), + new MediaFragmentSelector("xywh=0,0,200,200")).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(String, CanvasResource, String)}. + */ + @Test + public final void testTaggingAnnotationStringCanvasResourceOfCString() { + assertTrue(new TaggingAnnotation(ID_PATTERN + getRandom(), new Canvas(myMinter), "xywh=0,0,150,150").getID() + .startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(String, Manifest)}. + */ + @Test + public final void testTaggingAnnotationStringManifest() { + assertTrue(new TaggingAnnotation(ID_PATTERN + getRandom(), + new Manifest(ID_PATTERN + getRandom(), new Label("Label"))).getID().startsWith(ID_PATTERN)); + } + + /** + * Test method for {@link TaggingAnnotation#TaggingAnnotation(String, Target)}. + */ + @Test + public final void testTaggingAnnotationStringTarget() { + assertTrue(new TaggingAnnotation(ID_PATTERN + getRandom(), new Target(new Canvas(myMinter))).getID() + .startsWith(ID_PATTERN)); + } } diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/exts/geo/BoundingBoxTest.java b/src/test/java/info/freelibrary/iiif/presentation/v3/exts/geo/BoundingBoxTest.java new file mode 100644 index 00000000..205f224a --- /dev/null +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/exts/geo/BoundingBoxTest.java @@ -0,0 +1,150 @@ + +package info.freelibrary.iiif.presentation.v3.exts.geo; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import org.junit.Before; +import org.junit.Test; + +/** + * Tests of {@code BoundingBox}. + */ +public class BoundingBoxTest { + + /** + * Sets up the testing environment. + * + * @throws Exception + */ + @Before + public void setUp() throws Exception { + } + + /** + * Test method for {@link BoundingBox#BoundingBox(BoundingBox)}. + */ + @Test + public final void testBoundingBoxBoundingBox() { + final BoundingBox box = new BoundingBox(0, 0, 10, 10); + final BoundingBox testBox = new BoundingBox(box); + + assertEquals(0, testBox.getWest()); + assertEquals(0, testBox.getSouth()); + assertEquals(10, testBox.getEast()); + assertEquals(10, testBox.getNorth()); + } + + /** + * Test method for {@link BoundingBox#BoundingBox(double, double, double, double)}. + */ + @Test + public final void testBoundingBoxDoubleDoubleDoubleDouble() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#BoundingBox(double, double, double, double, double, double)}. + */ + @Test + public final void testBoundingBoxDoubleDoubleDoubleDoubleDoubleDouble() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#getEast()}. + */ + @Test + public final void testGetEast() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#getMaxAltitude()}. + */ + @Test + public final void testGetMaxAltitude() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#getMinAltitude()}. + */ + @Test + public final void testGetMinAltitude() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#getNorth()}. + */ + @Test + public final void testGetNorth() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#getSouth()}. + */ + @Test + public final void testGetSouth() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#getWest()}. + */ + @Test + public final void testGetWest() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#setEast(double)}. + */ + @Test + public final void testSetEast() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#setMaxAltitude(double)}. + */ + @Test + public final void testSetMaxAltitude() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#setMinAltitude(double)}. + */ + @Test + public final void testSetMinAltitude() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#setNorth(double)}. + */ + @Test + public final void testSetNorth() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#setSouth(double)}. + */ + @Test + public final void testSetSouth() { + fail("Not yet implemented"); + } + + /** + * Test method for {@link BoundingBox#setWest(double)}. + */ + @Test + public final void testSetWest() { + fail("Not yet implemented"); + } + +} diff --git a/src/test/java/info/freelibrary/iiif/presentation/v3/utils/TestUtils.java b/src/test/java/info/freelibrary/iiif/presentation/v3/utils/TestUtils.java index 819b4164..0bf5ed53 100644 --- a/src/test/java/info/freelibrary/iiif/presentation/v3/utils/TestUtils.java +++ b/src/test/java/info/freelibrary/iiif/presentation/v3/utils/TestUtils.java @@ -14,6 +14,7 @@ import java.util.Base64.Encoder; import java.util.Collections; import java.util.List; +import java.util.concurrent.ThreadLocalRandom; import org.junit.Assert; import org.junit.rules.TestName; @@ -105,6 +106,22 @@ public static String format(final String aJsonString) { } } + /** + * Creates an ID suffix. + * + * @return An ID suffix + */ + public static String getRandom() { + final ThreadLocalRandom random = ThreadLocalRandom.current(); + final StringBuilder buffer = new StringBuilder(); + + for (int index = 0; index < 4; index++) { + buffer.append(random.nextInt(10)); + } + + return buffer.toString(); + } + /** * Returns an object as JSON. *