method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
CannonDestination extends SimpleDestination { @Override public boolean equals(final Object o) { return this == o || ((o != null) && (getClass() == o.getClass()) && Locations.equal(this.coordinates, ((CannonDestination) o).coordinates) && this.speed == ((CannonDestination) o).speed); } CannonDestination(@NotNull MultiverseCoreAPI api, @Nullable EntityCoordinates coordinates, double speed); @Override @NotNull String getDestinationString(); @Override void teleport(@NotNull Permissible teleporter, @NotNull Entity teleportee); @Override boolean equals(final Object o); @Override int hashCode(); double getLaunchSpeed(); }### Answer:
@Test public void testEquals() throws Exception { CannonDestination a = new CannonDestination(api, null, 5); CannonDestination b = new CannonDestination(api, null, 5); assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertFalse(a.equals(null)); assertFalse(b.equals(null)); b = new CannonDestination(api, null, 4); assertFalse(a.equals(b)); assertFalse(b.equals(a)); b = new CannonDestination(api, Locations.getEntityCoordinates("someworld", UUID.randomUUID(), 0, 0, 0, 0, 0), 5); assertFalse(a.equals(b)); assertFalse(b.equals(a)); a = new CannonDestination(api, Locations.getEntityCoordinates("someworld", UUID.randomUUID(), 0, 0, 0, 0, 0), 5); assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertFalse(a.equals(null)); assertFalse(b.equals(null)); } |
### Question:
PlayerDestination extends SimpleDestination { @NotNull @Override protected EntityCoordinates getDestination() throws TeleportException { BasePlayer player = this.getApi().getServerInterface().getPlayer(playerName); if (player instanceof Entity) { return ((Entity) player).getLocation(); } else { throw new TeleportException(Message.bundleMessage(NOT_FOUND, playerName)); } } PlayerDestination(@NotNull MultiverseCoreAPI api, @NotNull String playerName); @NotNull @Override String getDestinationString(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testGetOnlinePlayerDestination() throws Exception { assertNotNull(factory.createDestination(api, "player:someplayer").getDestination()); }
@Test(expected = TeleportException.class) public void testGetOfflinePlayerDestination() throws Exception { PlayerDestination dest = factory.createDestination(api, "player:fakeplayer"); dest.getDestination(); }
@Test public void testTeleportLocation() throws Exception { BasePlayer player = api.getServerInterface().getPlayer("Player"); assertNotNull(player); ((Entity) player).teleport(Locations.getEntityCoordinates("someworld", UUID.randomUUID(), 50.5, 50, 50.5, 0, 0)); PlayerDestination dest = new PlayerDestination(api, "someplayer"); assertNotEquals(dest.getDestination(), ((Entity) player).getLocation()); assertEquals(1, ((Entity) player).getVelocity().length(), 0.00001); dest.teleport(player, (Entity) player); assertEquals(dest.getDestination(), ((Entity) player).getLocation()); assertEquals(1, ((Entity) player).getVelocity().length(), 0.00001); } |
### Question:
WorldManager { public boolean unloadWorld(@NotNull final String name) throws WorldManagementException { final MultiverseWorld world = getWorld(name); if (world != null) { unloadWorld(world); return true; } return false; } WorldManager(@NotNull final MultiverseCoreAPI api, @NotNull final WorldManagerUtil worldManagerUtil); @NotNull UUID getWorldUUID(@NotNull String worldName); @NotNull MultiverseWorld addWorld(@NotNull final String name,
@Nullable final WorldEnvironment env,
@Nullable final String seedString,
@Nullable final WorldType type,
@Nullable final Boolean generateStructures,
@Nullable final String generator); @NotNull MultiverseWorld addWorld(@NotNull final String name,
@Nullable final WorldEnvironment env,
@Nullable final String seedString,
@Nullable final WorldType type,
@Nullable final Boolean generateStructures,
@Nullable final String generator,
boolean useSpawnAdjust); @NotNull MultiverseWorld addWorld(@NotNull final WorldCreationSettings settings); boolean isLoaded(@NotNull final String name); boolean isManaged(@NotNull final String name); @Nullable MultiverseWorld getWorld(@NotNull final String name); @NotNull Collection<MultiverseWorld> getWorlds(); @NotNull MultiverseWorld loadWorld(@NotNull final String name); boolean unloadWorld(@NotNull final String name); void unloadWorld(@NotNull final MultiverseWorld world); void saveWorld(@NotNull MultiverseWorld world); void removePlayersFromWorld(@NotNull final MultiverseWorld world); @NotNull Collection<String> getUnloadedWorlds(); boolean removeWorld(@NotNull final String name); void deleteWorld(@NotNull final String worldName, final boolean removeMVWorld); boolean isThisAWorld(@NotNull final String name); @NotNull BundledMessage whatWillThisDelete(@NotNull final String name); @NotNull Collection<String> getPotentialWorlds(); }### Answer:
@Test public void testUnloadWorld() throws Exception { } |
### Question:
WorldManager { @NotNull public Collection<String> getUnloadedWorlds() { final Collection<String> managedWorlds = this.worldManagerUtil.getManagedWorldNames(); final List<String> unloadedWorlds = new ArrayList<String>(managedWorlds.size() - getWorlds().size()); for (final String name : managedWorlds) { if (!isLoaded(name)) { unloadedWorlds.add(name); } } return Collections.unmodifiableList(unloadedWorlds); } WorldManager(@NotNull final MultiverseCoreAPI api, @NotNull final WorldManagerUtil worldManagerUtil); @NotNull UUID getWorldUUID(@NotNull String worldName); @NotNull MultiverseWorld addWorld(@NotNull final String name,
@Nullable final WorldEnvironment env,
@Nullable final String seedString,
@Nullable final WorldType type,
@Nullable final Boolean generateStructures,
@Nullable final String generator); @NotNull MultiverseWorld addWorld(@NotNull final String name,
@Nullable final WorldEnvironment env,
@Nullable final String seedString,
@Nullable final WorldType type,
@Nullable final Boolean generateStructures,
@Nullable final String generator,
boolean useSpawnAdjust); @NotNull MultiverseWorld addWorld(@NotNull final WorldCreationSettings settings); boolean isLoaded(@NotNull final String name); boolean isManaged(@NotNull final String name); @Nullable MultiverseWorld getWorld(@NotNull final String name); @NotNull Collection<MultiverseWorld> getWorlds(); @NotNull MultiverseWorld loadWorld(@NotNull final String name); boolean unloadWorld(@NotNull final String name); void unloadWorld(@NotNull final MultiverseWorld world); void saveWorld(@NotNull MultiverseWorld world); void removePlayersFromWorld(@NotNull final MultiverseWorld world); @NotNull Collection<String> getUnloadedWorlds(); boolean removeWorld(@NotNull final String name); void deleteWorld(@NotNull final String worldName, final boolean removeMVWorld); boolean isThisAWorld(@NotNull final String name); @NotNull BundledMessage whatWillThisDelete(@NotNull final String name); @NotNull Collection<String> getPotentialWorlds(); }### Answer:
@Test public void testGetUnloadedWorlds() throws Exception { } |
### Question:
PlayerDestination extends SimpleDestination { @Override public boolean equals(final Object o) { return this == o || !(o == null || getClass() != o.getClass()) && playerName.equals(((PlayerDestination) o).playerName); } PlayerDestination(@NotNull MultiverseCoreAPI api, @NotNull String playerName); @NotNull @Override String getDestinationString(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testEquals() throws Exception { PlayerDestination a = new PlayerDestination(api, "player"); PlayerDestination b = new PlayerDestination(api, "player"); assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertFalse(a.equals(null)); assertFalse(b.equals(null)); b = new PlayerDestination(api, "player2"); assertFalse(a.equals(b)); assertFalse(b.equals(a)); } |
### Question:
WorldDestination extends SimpleDestination { @NotNull @Override protected EntityCoordinates getDestination() throws TeleportException { MultiverseWorld mvWorld = this.getApi().getWorldManager().getWorld(world); if (mvWorld == null) { throw new TeleportException(Message.bundleMessage(NOT_LOADED, world)); } return Locations.getEntityCoordinates(world, getApi().getWorldManager().getWorldUUID(world), mvWorld.getSpawnLocation()); } WorldDestination(@NotNull MultiverseCoreAPI api, @NotNull String world); @Override String getDestinationString(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testGetDestination() throws Exception { WorldDestination dest = factory.createDestination(api, "world:world"); assertNotNull(dest.getDestination()); assertTrue(Locations.equal(api.getWorldManager().getWorld("world").getSpawnLocation(), dest.getDestination())); }
@Test public void testTeleportLocation() throws Exception { BasePlayer player = api.getServerInterface().getPlayer("Player"); assertNotNull(player); ((Entity) player).teleport(Locations.getEntityCoordinates("someworld", UUID.randomUUID(), 50.5, 50, 50.5, 0, 0)); WorldDestination dest = new WorldDestination(api, "world"); assertNotEquals(dest.getDestination(), ((Entity) player).getLocation()); assertEquals(1, ((Entity) player).getVelocity().length(), 0.00001); dest.teleport(player, (Entity) player); assertEquals(dest.getDestination(), ((Entity) player).getLocation()); assertEquals(1, ((Entity) player).getVelocity().length(), 0.00001); } |
### Question:
WorldDestination extends SimpleDestination { @Override public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final WorldDestination that = (WorldDestination) o; return world.equals(that.world); } WorldDestination(@NotNull MultiverseCoreAPI api, @NotNull String world); @Override String getDestinationString(); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void testEquals() throws Exception { WorldDestination a = new WorldDestination(api, "world"); WorldDestination b = new WorldDestination(api, "world"); assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertFalse(a.equals(null)); assertFalse(b.equals(null)); b = new WorldDestination(api, "someworld"); assertFalse(a.equals(b)); assertFalse(b.equals(a)); } |
### Question:
DestinationRegistry { public void registerDestinationFactory(@NotNull DestinationFactory destinationFactory) { CoreLogger.fine("Registering DestinationFactory: " + destinationFactory); if (destinationFactory.getDestinationPrefixes().isEmpty()) { CoreLogger.warning("DestinationFactory: %s cannot be registered without any prefixes.", destinationFactory.getClass()); } for (String prefix : destinationFactory.getDestinationPrefixes()) { if (prefix.isEmpty()) { CoreLogger.warning("DestinationFactory: %s attempted to register an empty prefix.", destinationFactory.getClass()); continue; } prefix = prefix.toLowerCase(); if (!prefixFactoryMap.containsKey(prefix) || !destinationFactory.getWeakPrefixes().contains(prefix)) { prefixFactoryMap.put(prefix, destinationFactory); CoreLogger.finer("Registered prefix: %s to DestinationFactory: %s", prefix, destinationFactory.getClass()); } else { CoreLogger.finer("Skipped weak prefix: %s for DestinationFactory: %s as that prefix has previously been registered.", prefix, destinationFactory.getClass()); } } } DestinationRegistry(@NotNull final MultiverseCoreAPI api); void registerDestinationFactory(@NotNull DestinationFactory destinationFactory); @NotNull Destination parseDestination(@NotNull final String destinationString); }### Answer:
@Test public void testRegisterDestinationFactory() throws Exception { for (String prefix : TestDestination.PREFIXES) { assertNull(registry.getDestinationFactory(prefix)); } registry.registerDestinationFactory(new TestDestination.Factory()); for (String prefix : TestDestination.PREFIXES) { assertNotNull(registry.getDestinationFactory(prefix)); } } |
### Question:
IsInterfaceMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isInterface(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingInterface() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(Serializable.class); MatcherAssert.assertThat("Should return true for interface : ", CoreMatchers.IS_INTERFACE.getMatcher().check(typeElement)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingMethod_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non method : ", !CoreMatchers.IS_INTERFACE.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_INTERFACE.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsFieldMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isField(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingInterface() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(IsFieldMatcherTest.class); List<? extends Element> fieldList = ElementUtils.AccessEnclosedElements.getEnclosedElementsByName(typeElement, "testField"); MatcherAssert.assertThat("Precondition: must have found a field", fieldList.size() >= 1); MatcherAssert.assertThat("Should return true for field : ", CoreMatchers.IS_FIELD.getMatcher().check(fieldList.get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingMethod_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non field : ", !CoreMatchers.IS_FIELD.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_FIELD.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsGetterMethodMatcher implements ImplicitMatcher<ExecutableElement> { @Override public boolean check(ExecutableElement element) { if (element == null) { return false; } if (!FluentElementValidator.createFluentElementValidator(element) .applyValidator(CoreMatchers.BY_MODIFIER).hasAllOf(Modifier.PUBLIC) .applyValidator(CoreMatchers.BY_MODIFIER).hasNoneOf(Modifier.STATIC, Modifier.ABSTRACT) .applyValidator(CoreMatchers.HAS_NO_PARAMETERS) .applyInvertedValidator(CoreMatchers.HAS_VOID_RETURN_TYPE) .justValidate() ) { return false; } TypeMirror returnType = element.getReturnType(); String methodName = element.getSimpleName().toString(); return methodName.startsWith("get") || (TypeUtils.TypeComparison.isTypeEqual(returnType, TypeUtils.TypeRetrieval.getTypeMirror(boolean.class)) && ((methodName.startsWith("is") || methodName.startsWith("has")))); } @Override boolean check(ExecutableElement element); }### Answer:
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_GETTER_METHOD.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByReturnTypeMatcher implements CriteriaMatcher<ExecutableElement, Class> { @Override public String getStringRepresentationOfPassedCharacteristic(Class toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.getCanonicalName() : ""; } ByReturnTypeMatcher(); @Override boolean checkForMatchingCharacteristic(ExecutableElement element, Class toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(Class toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_RETURN_TYPE.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.is("")); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepresetation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should have created valid string representation", CoreMatchers.BY_RETURN_TYPE.getMatcher().getStringRepresentationOfPassedCharacteristic(String.class), Matchers.is(String.class.getCanonicalName())); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsAnnotationTypeMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isAnnotation(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingAnnotationType() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(Override.class); MatcherAssert.assertThat("Should return true for annotation type : ", CoreMatchers.IS_ANNOTATION_TYPE.getMatcher().check(typeElement)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingAnnotationType() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non annotation (class) : ", !CoreMatchers.IS_ANNOTATION_TYPE.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_ANNOTATION_TYPE.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsPackageMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isPackage(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingPackage() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { Element result = ElementUtils.AccessEnclosingElements.getFirstEnclosingElementOfKind(element, ElementKind.PACKAGE); MatcherAssert.assertThat("Precondition: should have found one method", result != null); MatcherAssert.assertThat("Precondition: found method has to be of type package", result instanceof PackageElement); MatcherAssert.assertThat("Should return true for method : ", CoreMatchers.IS_PACKAGE.getMatcher().check(result)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingPackageElement_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non Package : ", !CoreMatchers.IS_PACKAGE.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_PACKAGE.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsSetterMethodMatcher implements ImplicitMatcher<ExecutableElement> { @Override public boolean check(ExecutableElement element) { if (element == null) { return false; } return FluentElementValidator.createFluentElementValidator(element) .applyValidator(CoreMatchers.BY_MODIFIER).hasAllOf(Modifier.PUBLIC) .applyValidator(CoreMatchers.BY_MODIFIER).hasNoneOf(Modifier.STATIC, Modifier.ABSTRACT) .applyValidator(CoreMatchers.BY_NUMBER_OF_PARAMETERS).hasOneOf(1) .applyValidator(CoreMatchers.HAS_VOID_RETURN_TYPE) .applyValidator(CoreMatchers.BY_REGEX_NAME).hasOneOf("set.*") .justValidate(); } @Override boolean check(ExecutableElement element); }### Answer:
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_SETTER_METHOD.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByReturnTypeMirrorMatcher implements CriteriaMatcher<ExecutableElement, TypeMirror> { @Override public String getStringRepresentationOfPassedCharacteristic(TypeMirror toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.toString() : ""; } ByReturnTypeMirrorMatcher(); @Override boolean checkForMatchingCharacteristic(ExecutableElement element, TypeMirror toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(TypeMirror toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_RETURN_TYPE_MIRROR.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.is("")); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepresentation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should have created valid string representation", CoreMatchers.BY_RETURN_TYPE_MIRROR.getMatcher().getStringRepresentationOfPassedCharacteristic(TypeUtils.TypeRetrieval.getTypeMirror(String.class)), Matchers.is(String.class.getCanonicalName())); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsTypeElementMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CastElement.isTypeElement(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingTypeElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non TypeElement : ", CoreMatchers.IS_TYPE_ELEMENT.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingTypeElement_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { Element result = ElementUtils.AccessEnclosingElements.getFirstEnclosingElementOfKind(element, ElementKind.PACKAGE); MatcherAssert.assertThat("Precondition: should have found one method", result != null); MatcherAssert.assertThat("Precondition: found method has to be of zype PackageElement", result instanceof PackageElement); MatcherAssert.assertThat("Should return false for package : ", !CoreMatchers.IS_TYPE_ELEMENT.getMatcher().check(result)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_TYPE_ELEMENT.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsExecutableElementMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CastElement.isExecutableElement(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingExecutableElement_method() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { List<? extends Element> result = ElementUtils.AccessEnclosedElements.getEnclosedElementsByName(element, "methodWithReturnTypeAndParameters"); MatcherAssert.assertThat("Precondition: should have found one method", result.size() == 1); MatcherAssert.assertThat("Precondition: found method has to be of type ExecutableElement", result.get(0) instanceof ExecutableElement); MatcherAssert.assertThat("Should return true for method : ", CoreMatchers.IS_EXECUTABLE_ELEMENT.getMatcher().check(result.get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingExecutableElement_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non ExecutableElement : ", !CoreMatchers.IS_EXECUTABLE_ELEMENT.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_EXECUTABLE_ELEMENT.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByParameterTypeMatcher implements CriteriaMatcher<ExecutableElement, Class[]> { @Override public String getStringRepresentationOfPassedCharacteristic(Class[] toGetStringRepresentationFor) { if (toGetStringRepresentationFor != null) { StringBuilder stringBuilder = new StringBuilder("["); boolean isFirst = true; for (Class<?> element : toGetStringRepresentationFor) { if (isFirst) { isFirst = false; } else { stringBuilder.append(", "); } stringBuilder.append(element.getCanonicalName()); } stringBuilder.append("]"); return stringBuilder.toString(); } else { return null; } } ByParameterTypeMatcher(); @Override boolean checkForMatchingCharacteristic(ExecutableElement element, Class[] toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(Class[] toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_PARAMETER_TYPE.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.nullValue()); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepresentation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should have created valid string representation", CoreMatchers.BY_PARAMETER_TYPE.getMatcher().getStringRepresentationOfPassedCharacteristic(Utilities.convertVarargsToArray(String.class, Boolean.class)), Matchers.is("[java.lang.String, java.lang.Boolean]")); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByParameterTypeMirrorMatcher implements CriteriaMatcher<ExecutableElement, TypeMirror[]> { @Override public String getStringRepresentationOfPassedCharacteristic(TypeMirror[] toGetStringRepresentationFor) { if (toGetStringRepresentationFor != null) { StringBuilder stringBuilder = new StringBuilder("["); boolean isFirst = true; for (TypeMirror element : toGetStringRepresentationFor) { if (isFirst) { isFirst = false; } else { stringBuilder.append(", "); } stringBuilder.append(element.toString()); } stringBuilder.append("]"); return stringBuilder.toString(); } else { return null; } } ByParameterTypeMirrorMatcher(); @Override boolean checkForMatchingCharacteristic(ExecutableElement element, TypeMirror[] toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(TypeMirror[] toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_PARAMETER_TYPE_MIRROR.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.nullValue()); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepresentation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should have created valid string representation", CoreMatchers.BY_PARAMETER_TYPE_MIRROR.getMatcher().getStringRepresentationOfPassedCharacteristic(Utilities.convertVarargsToArray(TypeUtils.TypeRetrieval.getTypeMirror(String.class), TypeUtils.TypeRetrieval.getTypeMirror(Boolean.class))), Matchers.is("[java.lang.String, java.lang.Boolean]")); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsPackageElementMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CastElement.isPackageElement(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingPackageElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { Element result = ElementUtils.AccessEnclosingElements.getFirstEnclosingElementOfKind(element, ElementKind.PACKAGE); MatcherAssert.assertThat("Precondition: should have found one method", result != null); MatcherAssert.assertThat("Precondition: found method has to be of type PackageElement", result instanceof PackageElement); MatcherAssert.assertThat("Should return true for method : ", CoreMatchers.IS_PACKAGE_ELEMENT.getMatcher().check(result)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingPackageElement_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non PackageElement : ", !CoreMatchers.IS_PACKAGE_ELEMENT.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_PACKAGE_ELEMENT.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByElementKindMatcher implements CriteriaMatcher<Element, ElementKind> { @Override public String getStringRepresentationOfPassedCharacteristic(ElementKind toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.name() : null; } @Override boolean checkForMatchingCharacteristic(Element element, ElementKind toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(ElementKind toGetStringRepresentationFor); }### Answer:
@Test public void test_getStringRepresentationOfPassedCharacteristic_happyPath() { MatcherAssert.assertThat("Should return cannonical class name of annotation class", unit.getStringRepresentationOfPassedCharacteristic(ElementKind.ENUM).equals(ElementKind.ENUM.name())); }
@Test public void test_getStringRepresentationOfPassedCharacteristic_passedNullValue() { MatcherAssert.assertThat("Should return null for null valued parameter", unit.getStringRepresentationOfPassedCharacteristic(null) == null); } |
### Question:
ByElementKindMatcher implements CriteriaMatcher<Element, ElementKind> { @Override public boolean checkForMatchingCharacteristic(Element element, ElementKind toCheckFor) { return (element != null && toCheckFor != null) && element.getKind().equals(toCheckFor); } @Override boolean checkForMatchingCharacteristic(Element element, ElementKind toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(ElementKind toGetStringRepresentationFor); }### Answer:
@Test public void test_checkForMatchingCharacteristic_match() { Element element = Mockito.mock(Element.class); Mockito.when(element.getKind()).thenReturn(ElementKind.CLASS); MatcherAssert.assertThat("Should find match correctly", unit.checkForMatchingCharacteristic(element, ElementKind.CLASS)); }
@Test public void test_checkForMatchingCharacteristic_mismatch() { Element element = Mockito.mock(Element.class); Mockito.when(element.getKind()).thenReturn(ElementKind.CLASS); MatcherAssert.assertThat("Should find mismatch correctly", !unit.checkForMatchingCharacteristic(element, ElementKind.INTERFACE)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedElement() { MatcherAssert.assertThat("Should return false in case of null valued element", !unit.checkForMatchingCharacteristic(null, ElementKind.CLASS)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedElementKind() { Element element = Mockito.mock(Element.class); MatcherAssert.assertThat("Should return false in case of null valued annotation", !unit.checkForMatchingCharacteristic(element, null)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedParameters() { MatcherAssert.assertThat("Should return false in case of null valued parameters", !unit.checkForMatchingCharacteristic(null, null)); } |
### Question:
ByReturnTypeFqnMatcher implements CriteriaMatcher<ExecutableElement, String> { @Override public String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor : ""; } ByReturnTypeFqnMatcher(); @Override boolean checkForMatchingCharacteristic(ExecutableElement element, String toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_RETURN_TYPE_FQN.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.is("")); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepresentation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should have created valid string representation", CoreMatchers.BY_RETURN_TYPE_FQN.getMatcher().getStringRepresentationOfPassedCharacteristic(String.class.getCanonicalName()), Matchers.is(String.class.getCanonicalName())); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByQualifiedNameMatcher implements CriteriaMatcher<Element, String> { @Override public String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor) { return toGetStringRepresentationFor; } @Override boolean checkForMatchingCharacteristic(Element element, String toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor); }### Answer:
@Test public void test_getStringRepresentationOfPassedCharacteristic_happyPath() { MatcherAssert.assertThat("Should return enum name", unit.getStringRepresentationOfPassedCharacteristic(NAME).equals(NAME)); }
@Test public void test_getStringRepresentationOfPassedCharacteristic_passedNullValue() { MatcherAssert.assertThat("Should return null for null valued parameter", unit.getStringRepresentationOfPassedCharacteristic(null) == null); } |
### Question:
SimpleResourceReader { public String readAsString() throws IOException { char[] buffer = new char[10000]; CharArrayWriter writer = new CharArrayWriter(); int line = 0; while ((line = foReader.read(buffer)) != -1) { writer.write(buffer, 0, line); } foReader.close(); writer.flush(); writer.close(); return writer.toString(); } SimpleResourceReader(FileObject fileObject); String readLine(); String readAsString(); List<String> readAsLines(); List<String> readAsLines(boolean trimLines); Properties readAsProperties(); void close(); }### Answer:
@Test public void testReadAsString() throws IOException { final String RESOURCE_STRING = "abc\ndef\nhij"; FileObject fileObject = Mockito.mock(FileObject.class); StringReader stringReader = Mockito.spy(new StringReader(RESOURCE_STRING)); Mockito.when(fileObject.openReader(Mockito.anyBoolean())).thenReturn(stringReader); SimpleResourceReader unit = new SimpleResourceReader(fileObject); MatcherAssert.assertThat(unit.readAsString(), Matchers.equalTo(RESOURCE_STRING)); Mockito.verify(stringReader, Mockito.times(1)).close(); } |
### Question:
IsConstructorMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isConstructor(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingConstructor() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(IsConstructorMatcherTest.class); List<? extends Element> constructors = ElementUtils.AccessEnclosedElements.getEnclosedElementsOfKind(typeElement, ElementKind.CONSTRUCTOR); MatcherAssert.assertThat("Precondition: must have found a enum", constructors.size() >= 1); MatcherAssert.assertThat("Should return true for enum : ", CoreMatchers.IS_CONSTRUCTOR.getMatcher().check(constructors.get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingConstructor() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non constructor : ", !CoreMatchers.IS_CONSTRUCTOR.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checknullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_CONSTRUCTOR.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
SimpleResourceReader { public List<String> readAsLines() throws IOException { return readAsLines(false); } SimpleResourceReader(FileObject fileObject); String readLine(); String readAsString(); List<String> readAsLines(); List<String> readAsLines(boolean trimLines); Properties readAsProperties(); void close(); }### Answer:
@Test public void testReadAsLines() throws IOException { final String RESOURCE_STRING = "abc\ndef\nhij"; FileObject fileObject = Mockito.mock(FileObject.class); StringReader stringReader = Mockito.spy(new StringReader(RESOURCE_STRING)); Mockito.when(fileObject.openReader(Mockito.anyBoolean())).thenReturn(stringReader); SimpleResourceReader unit = new SimpleResourceReader(fileObject); MatcherAssert.assertThat(unit.readAsLines(), Matchers.contains("abc", "def", "hij")); Mockito.verify(stringReader, Mockito.times(1)).close(); } |
### Question:
IsAssignableToMatcher implements CriteriaMatcher<Element, Class> { @Override public String getStringRepresentationOfPassedCharacteristic(Class toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.getCanonicalName() : null; } @Override String getStringRepresentationOfPassedCharacteristic(Class toGetStringRepresentationFor); @Override boolean checkForMatchingCharacteristic(Element element, Class toCheckFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.IS_ASSIGNABLE_TO.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.nullValue()); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepresentation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.IS_ASSIGNABLE_TO.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.nullValue()); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
HasNoThrownTypesMatcher implements ImplicitMatcher<ExecutableElement> { @Override public boolean check(ExecutableElement element) { return element != null && element.getThrownTypes().size() == 0; } @Override boolean check(ExecutableElement element); }### Answer:
@Test public void test_check_withNullValue() { MatcherAssert.assertThat(CoreMatchers.HAS_NO_THROWN_TYPES.getMatcher().check(null), Matchers.is(false)); }
@Test public void test_check_withoutThrownTypes() { ExecutableElement element = Mockito.mock(ExecutableElement.class); TypeMirror typeMirror = Mockito.mock(TypeMirror.class); Mockito.when(element.getThrownTypes()).thenReturn(Collections.EMPTY_LIST); MatcherAssert.assertThat(CoreMatchers.HAS_NO_THROWN_TYPES.getMatcher().check(element), Matchers.is(true)); }
@Test public void test_check_withNonVoidReturnType() { ExecutableElement element = Mockito.mock(ExecutableElement.class); TypeMirror typeMirror = Mockito.mock(TypeMirror.class); List list = new ArrayList<TypeMirror>(); list.add(Mockito.mock(TypeMirror.class)); Mockito.when(element.getThrownTypes()).thenReturn(list); MatcherAssert.assertThat(CoreMatchers.HAS_NO_THROWN_TYPES.getMatcher().check(element), Matchers.is(false)); } |
### Question:
SimpleResourceReader { public Properties readAsProperties() throws IOException { Properties properties = new Properties(); try { properties.load(foReader); } finally { foReader.close(); } return properties; } SimpleResourceReader(FileObject fileObject); String readLine(); String readAsString(); List<String> readAsLines(); List<String> readAsLines(boolean trimLines); Properties readAsProperties(); void close(); }### Answer:
@Test public void testReadAsProperties() throws IOException { final String RESOURCE_STRING = "a=1\nb=2\nc=3"; FileObject fileObject = Mockito.mock(FileObject.class); StringReader stringReader = Mockito.spy(new StringReader(RESOURCE_STRING)); Mockito.when(fileObject.openReader(Mockito.anyBoolean())).thenReturn(stringReader); SimpleResourceReader unit = new SimpleResourceReader(fileObject); Properties result = unit.readAsProperties(); MatcherAssert.assertThat(result.get("a"), Matchers.equalTo((Object) "1")); MatcherAssert.assertThat(result.get("b"), Matchers.equalTo((Object) "2")); MatcherAssert.assertThat(result.get("c"), Matchers.equalTo((Object) "3")); Mockito.verify(stringReader, Mockito.times(1)).close(); } |
### Question:
HasVoidReturnTypeMatcher implements ImplicitMatcher<ExecutableElement> { @Override public boolean check(ExecutableElement element) { return element != null && TypeUtils.CheckTypeKind.isVoid(element.getReturnType()); } @Override boolean check(ExecutableElement element); }### Answer:
@Test public void test_check_withNullValue() { MatcherAssert.assertThat(CoreMatchers.HAS_VOID_RETURN_TYPE.getMatcher().check(null), Matchers.is(false)); }
@Test public void test_check_withVoidReturnType() { ExecutableElement element = Mockito.mock(ExecutableElement.class); TypeMirror typeMirror = Mockito.mock(TypeMirror.class); Mockito.when(element.getReturnType()).thenReturn(typeMirror); Mockito.when(typeMirror.getKind()).thenReturn(TypeKind.VOID); MatcherAssert.assertThat(CoreMatchers.HAS_VOID_RETURN_TYPE.getMatcher().check(element), Matchers.is(true)); }
@Test public void test_check_withNonVoidReturnType() { ExecutableElement element = Mockito.mock(ExecutableElement.class); TypeMirror typeMirror = Mockito.mock(TypeMirror.class); Mockito.when(element.getReturnType()).thenReturn(typeMirror); Mockito.when(typeMirror.getKind()).thenReturn(TypeKind.ARRAY); MatcherAssert.assertThat(CoreMatchers.HAS_VOID_RETURN_TYPE.getMatcher().check(element), Matchers.is(false)); } |
### Question:
ByNameRegexMatcher implements CriteriaMatcher<Element, String> { @Override public String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor) { return toGetStringRepresentationFor; } @Override boolean checkForMatchingCharacteristic(Element element, String toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor); }### Answer:
@Test public void test_getStringRepresentationOfPassedCharacteristic_happyPath() { MatcherAssert.assertThat("Should return enum name", unit.getStringRepresentationOfPassedCharacteristic(NAME).equals(NAME)); }
@Test public void test_getStringRepresentationOfPassedCharacteristic_passedNullValue() { MatcherAssert.assertThat("Should return null for null valued parameter", unit.getStringRepresentationOfPassedCharacteristic(null) == null); } |
### Question:
ByNumberOfParametersMatcher implements CriteriaMatcher<ExecutableElement, Integer> { @Override public String getStringRepresentationOfPassedCharacteristic(Integer toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.toString() : null; } @Override boolean checkForMatchingCharacteristic(ExecutableElement element, Integer toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(Integer toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_NUMBER_OF_PARAMETERS.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.nullValue()); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepresentation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_NUMBER_OF_PARAMETERS.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.nullValue()); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByNameMatcher implements CriteriaMatcher<Element, String> { @Override public String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor) { return toGetStringRepresentationFor; } @Override boolean checkForMatchingCharacteristic(Element element, String toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor); }### Answer:
@Test public void test_getStringRepresentationOfPassedCharacteristic_happyPath() { MatcherAssert.assertThat("Should return enum name", unit.getStringRepresentationOfPassedCharacteristic(NAME).equals(NAME)); }
@Test public void test_getStringRepresentationOfPassedCharacteristic_passedNullValue() { MatcherAssert.assertThat("Should return null for null valued parameter", unit.getStringRepresentationOfPassedCharacteristic(null) == null); } |
### Question:
ByNameMatcher implements CriteriaMatcher<Element, String> { @Override public boolean checkForMatchingCharacteristic(Element element, String toCheckFor) { return (element != null && toCheckFor != null) && element.getSimpleName().toString().equals(toCheckFor); } @Override boolean checkForMatchingCharacteristic(Element element, String toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor); }### Answer:
@Test public void test_checkForMatchingCharacteristic_match() { Element element = Mockito.mock(Element.class); Name nameOfElement = Mockito.mock(Name.class); Mockito.when(nameOfElement.toString()).thenReturn(NAME); Mockito.when(element.getSimpleName()).thenReturn(nameOfElement); MatcherAssert.assertThat("Should find match correctly", unit.checkForMatchingCharacteristic(element, NAME)); }
@Test public void test_checkForMatchingCharacteristic_mismatch() { Element element = Mockito.mock(Element.class); Name nameOfElement = Mockito.mock(Name.class); Mockito.when(nameOfElement.toString()).thenReturn("XXX"); Mockito.when(element.getSimpleName()).thenReturn(nameOfElement); MatcherAssert.assertThat("Should find mismatch correctly", !unit.checkForMatchingCharacteristic(element, NAME)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedElement() { MatcherAssert.assertThat("Should return false in case of null valued element", !unit.checkForMatchingCharacteristic(null, NAME)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedAnnotationType() { Element element = Mockito.mock(Element.class); MatcherAssert.assertThat("Should retrun false in case of null valued annotation", !unit.checkForMatchingCharacteristic(element, null)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedParameters() { MatcherAssert.assertThat("Should retrun false in case of null valued parameters", !unit.checkForMatchingCharacteristic(null, null)); } |
### Question:
IsVariableElementMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CastElement.isVariableElement(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingVariableElement_field() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { List<? extends Element> result = ElementUtils.AccessEnclosedElements.getEnclosedElementsOfKind(TypeUtils.TypeRetrieval.getTypeElement(IsVariableElementMatcherTest.class), ElementKind.FIELD); MatcherAssert.assertThat("Precondition: should have found one field", result.size() >= 1); MatcherAssert.assertThat("Precondition: found method has to be of type VariableElement", result.get(0) instanceof VariableElement); MatcherAssert.assertThat("Should return true for field : ", CoreMatchers.IS_VARIABLE_ELEMENT.getMatcher().check(result.get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingVariableElement_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non VariableElement : ", !CoreMatchers.IS_VARIABLE_ELEMENT.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingVariableElement_nullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_VARIABLE_ELEMENT.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByQualifiedNameRegexMatcher implements CriteriaMatcher<Element, String> { @Override public String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor) { return toGetStringRepresentationFor; } @Override boolean checkForMatchingCharacteristic(Element element, String toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(String toGetStringRepresentationFor); }### Answer:
@Test public void test_getStringRepresentationOfPassedCharacteristic_happyPath() { MatcherAssert.assertThat("Should return enum name", unit.getStringRepresentationOfPassedCharacteristic(NAME).equals(NAME)); }
@Test public void test_getStringRepresentationOfPassedCharacteristic_passedNullValue() { MatcherAssert.assertThat("Should return null for null valued parameter", unit.getStringRepresentationOfPassedCharacteristic(null) == null); } |
### Question:
ByRawTypeMatcher implements CriteriaMatcher<Element, Class> { @Override public String getStringRepresentationOfPassedCharacteristic(Class toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.getCanonicalName() : null; } ByRawTypeMatcher(); @Override boolean checkForMatchingCharacteristic(Element element, Class toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(Class toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_happyPath() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return cannonical class name of annotation class", CoreMatchers.BY_RAW_TYPE.getMatcher().getStringRepresentationOfPassedCharacteristic(ByRawTypeMatcherTest.class).equals(ByRawTypeMatcherTest.class.getCanonicalName())); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_passedNullValue_shouldReturnNull() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return null for null valued parameter", CoreMatchers.BY_RAW_TYPE.getMatcher().getStringRepresentationOfPassedCharacteristic(null) == null); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByModifierMatcher implements CriteriaMatcher<Element, Modifier> { @Override public String getStringRepresentationOfPassedCharacteristic(Modifier toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.name() : null; } @Override boolean checkForMatchingCharacteristic(Element element, Modifier toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(Modifier toGetStringRepresentationFor); }### Answer:
@Test public void test_getStringRepresentationOfPassedCharacteristic_happyPath() { MatcherAssert.assertThat("Should return enum name", unit.getStringRepresentationOfPassedCharacteristic(Modifier.FINAL).equals(Modifier.FINAL.name())); }
@Test public void test_getStringRepresentationOfPassedCharacteristic_passedNullValue() { MatcherAssert.assertThat("Should return null for null valued parameter", unit.getStringRepresentationOfPassedCharacteristic(null) == null); } |
### Question:
ByModifierMatcher implements CriteriaMatcher<Element, Modifier> { @Override public boolean checkForMatchingCharacteristic(Element element, Modifier toCheckFor) { return (element != null && toCheckFor != null) && element.getModifiers().contains(toCheckFor); } @Override boolean checkForMatchingCharacteristic(Element element, Modifier toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(Modifier toGetStringRepresentationFor); }### Answer:
@Test public void test_checkForMatchingCharacteristic_match() { Element element = Mockito.mock(Element.class); Set<Modifier> modifierSet = new HashSet<Modifier>(); modifierSet.add(Modifier.FINAL); Mockito.when(element.getModifiers()).thenReturn(modifierSet); MatcherAssert.assertThat("Should find match correctly", unit.checkForMatchingCharacteristic(element, Modifier.FINAL)); }
@Test public void test_checkForMatchingCharacteristic_mismatch() { Element element = Mockito.mock(Element.class); Set<Modifier> modifierSet = new HashSet<Modifier>(); modifierSet.add(Modifier.FINAL); Mockito.when(element.getModifiers()).thenReturn(modifierSet); MatcherAssert.assertThat("Should find mismatch correctly", !unit.checkForMatchingCharacteristic(element, Modifier.PUBLIC)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedElement() { MatcherAssert.assertThat("Should return false in case of null valued element", !unit.checkForMatchingCharacteristic(null, Modifier.ABSTRACT)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedAnnotationType() { Element element = Mockito.mock(Element.class); MatcherAssert.assertThat("Should retrun false in case of null valued annotation", !unit.checkForMatchingCharacteristic(element, null)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedParameters() { MatcherAssert.assertThat("Should retrun false in case of null valued parameters", !unit.checkForMatchingCharacteristic(null, null)); } |
### Question:
TypeUtils { public static Types getTypes() { return ProcessingEnvironmentUtils.getTypes(); } private TypeUtils(); static Types getTypes(); }### Answer:
@Test public void typeUtils_typeRetrieval_getTypes_getEncapsulatedTypesInstance() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat(TypeUtils.getTypes(), Matchers.notNullValue()); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
Utilities { public static <T> Set<T> convertArrayToSet(T[] array) { if (array == null) { return null; } Set<T> set = new HashSet<>(array.length); for (T element : array) { if (element != null) { set.add(element); } } return set; } private Utilities(); static Set<T> convertArrayToSet(T[] array); @SafeVarargs static Set<T> convertVarargsToSet(T... varargs); @SafeVarargs static List<T> convertVarargsToList(T... varargs); @SafeVarargs static T[] convertVarargsToArray(T... varargs); }### Answer:
@Test public void convertArrayToSet_nullValue() { MatcherAssert.assertThat(Utilities.convertArrayToSet(null), Matchers.nullValue()); }
@Test public void convertArrayToSet_nonNullValue() { String[] array = {"A","B","C"}; MatcherAssert.assertThat(Utilities.convertArrayToSet(array), Matchers.containsInAnyOrder("A","B","C")); } |
### Question:
Utilities { @SafeVarargs public static <T> Set<T> convertVarargsToSet(T... varargs) { return varargs != null ? new HashSet<>(Arrays.asList(varargs)) : new HashSet<T>(); } private Utilities(); static Set<T> convertArrayToSet(T[] array); @SafeVarargs static Set<T> convertVarargsToSet(T... varargs); @SafeVarargs static List<T> convertVarargsToList(T... varargs); @SafeVarargs static T[] convertVarargsToArray(T... varargs); }### Answer:
@Test public void convertVarargsToSet_noValues_shouldReturnEmptySet() { MatcherAssert.assertThat(Utilities.convertVarargsToSet(), Matchers.empty()); }
@Test public void convertVarargsToSet_singleNullValue_shouldReturnEmptySet() { MatcherAssert.assertThat(Utilities.convertVarargsToSet(null), Matchers.empty()); }
@Test public void convertArrayToSet_withValues() { MatcherAssert.assertThat(Utilities.convertVarargsToSet("A","B", (String)null, "C"), Matchers.containsInAnyOrder("A","B","C", (String)null)); } |
### Question:
BeanUtils { public static String getPrefixedName(String prefix, String name) { return prefix + name.substring(0, 1).toUpperCase() + name.substring(1); } private BeanUtils(); static boolean hasDefaultNoargsConstructor(TypeElement typeElement); static boolean isDefaultNoargConstructor(ExecutableElement element); static boolean isAttribute(VariableElement field); static AttributeResult[] getAttributesWithInheritance(TypeElement typeElement); static AttributeResult[] getAttributes(TypeElement typeElement); static boolean checkHasGetter(VariableElement field); static boolean checkHasSetter(VariableElement field); static boolean checkLombokDataAnnotation(TypeElement typeElement); static boolean checkLombokGetterAnnotationOnType(TypeElement typeElement); static boolean checkLombokGetterAnnotationOnField(VariableElement variableElement); static String getGetterMethodName(VariableElement field); static String getSetterMethodName(VariableElement field); static String getPrefixedName(String prefix, String name); static boolean checkLombokSetterAnnotationOnType(TypeElement typeElement); static boolean checkLombokSetterAnnotationOnField(VariableElement variableElement); }### Answer:
@Test public void getPossibleGetterOrSetterNames_getter() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat(Arrays.asList(BeanUtils.getPrefixedName("get", "testField")), Matchers.contains("getTestField")); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
Utilities { @SafeVarargs public static <T> List<T> convertVarargsToList(T... varargs) { return varargs != null ? Arrays.asList(varargs) : new ArrayList<T>(); } private Utilities(); static Set<T> convertArrayToSet(T[] array); @SafeVarargs static Set<T> convertVarargsToSet(T... varargs); @SafeVarargs static List<T> convertVarargsToList(T... varargs); @SafeVarargs static T[] convertVarargsToArray(T... varargs); }### Answer:
@Test public void convertVarargsToList_noValues_shouldReturnEmptySet() { MatcherAssert.assertThat(Utilities.convertVarargsToList(), Matchers.empty()); }
@Test public void convertVarargsToList_singleNullValue_shouldReturnEmptySet() { MatcherAssert.assertThat(Utilities.convertVarargsToList(null), Matchers.empty()); }
@Test public void convertVarargsToList_withValues() { MatcherAssert.assertThat(Utilities.convertVarargsToList("A","B", (String)null, "C"), Matchers.contains("A","B", (String)null,"C")); } |
### Question:
Utilities { @SafeVarargs public static <T> T[] convertVarargsToArray(T... varargs) { final Object[] e = {}; if (varargs == null) { return (T[]) e; } return varargs; } private Utilities(); static Set<T> convertArrayToSet(T[] array); @SafeVarargs static Set<T> convertVarargsToSet(T... varargs); @SafeVarargs static List<T> convertVarargsToList(T... varargs); @SafeVarargs static T[] convertVarargsToArray(T... varargs); }### Answer:
@Test public void convertVarargsToArray_noValues_shouldReturnEmptySet() { MatcherAssert.assertThat(Arrays.asList(Utilities.convertVarargsToArray()), Matchers.empty()); }
@Test public void convertVarargsToArray_singleNullValue_shouldReturnEmptyArrayg() { MatcherAssert.assertThat(Arrays.asList(Utilities.convertVarargsToArray(null)), Matchers.empty()); }
@Test public void convertVarargsToArray_withValues() { MatcherAssert.assertThat(Arrays.asList(Utilities.convertVarargsToArray("A","B", (String)null, "C")), Matchers.contains("A","B", (String)null,"C")); } |
### Question:
AbstractAnnotationProcessor extends AbstractProcessor { @SafeVarargs protected static Set<String> createSupportedAnnotationSet(Class<? extends Annotation>... annotationTypes) { Set<String> result = new HashSet<>(); if (annotationTypes != null) { for (Class<? extends Annotation> annotationType : annotationTypes) { if (annotationType != null) { result.add(annotationType.getCanonicalName()); } } } return result; } @Override synchronized void init(ProcessingEnvironment processingEnv); @Override final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv); abstract boolean processAnnotations(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv); @Override SourceVersion getSupportedSourceVersion(); static Elements getElements(); static Filer getFiler(); static Types getTypes(); static Messager getMessager(); @SafeVarargs static T[] wrapToArray(T... element); }### Answer:
@Test public void createSupportedAnnotationSet_withoutParameters() { MatcherAssert.assertThat(AbstractAnnotationProcessor.createSupportedAnnotationSet(), Matchers.<String>empty()); }
@Test public void createSupportedAnnotationSet_withParameters() { MatcherAssert.assertThat(AbstractAnnotationProcessor.createSupportedAnnotationSet(Override.class, Ignore.class), Matchers.containsInAnyOrder(Override.class.getCanonicalName(), Ignore.class.getCanonicalName())); }
@Test public void createSupportedAnnotationSet_withNullParameter() { MatcherAssert.assertThat(AbstractAnnotationProcessor.createSupportedAnnotationSet(null), Matchers.<String>empty()); MatcherAssert.assertThat(AbstractAnnotationProcessor.createSupportedAnnotationSet(Override.class, null, Ignore.class), Matchers.containsInAnyOrder(Override.class.getCanonicalName(), Ignore.class.getCanonicalName())); } |
### Question:
AbstractAnnotationProcessor extends AbstractProcessor { @SafeVarargs public static <T> T[] wrapToArray(T... element) { return element; } @Override synchronized void init(ProcessingEnvironment processingEnv); @Override final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv); abstract boolean processAnnotations(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv); @Override SourceVersion getSupportedSourceVersion(); static Elements getElements(); static Filer getFiler(); static Types getTypes(); static Messager getMessager(); @SafeVarargs static T[] wrapToArray(T... element); }### Answer:
@Test public void wrapToArrayt_withNullParameter() { MatcherAssert.assertThat("Should return null", AbstractAnnotationProcessor.wrapToArray((String) null)[0] == null); Class[] resultArray = AbstractAnnotationProcessor.wrapToArray(Override.class, null, Ignore.class); MatcherAssert.assertThat(Arrays.asList(resultArray), Matchers.hasSize(3)); MatcherAssert.assertThat(resultArray[0], Matchers.equalTo((Class) Override.class)); MatcherAssert.assertThat(resultArray[1], Matchers.nullValue()); MatcherAssert.assertThat(resultArray[2], Matchers.equalTo((Class) Ignore.class)); } |
### Question:
ToolingProvider { public static void setTooling(ProcessingEnvironment processingEnvironment) { tooling.set(new ToolingProvider(processingEnvironment)); } ToolingProvider(ProcessingEnvironment processingEnv); static ToolingProvider getTooling(); static void setTooling(ProcessingEnvironment processingEnvironment); static void clearTooling(); Elements getElements(); Filer getFiler(); Messager getMessager(); Types getTypes(); ProcessingEnvironment getProcessingEnvironment(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testToolingProviderSetToolingWithNullValue() { ToolingProvider.setTooling(null); } |
### Question:
ToolingProvider { public static void clearTooling() { tooling.remove(); } ToolingProvider(ProcessingEnvironment processingEnv); static ToolingProvider getTooling(); static void setTooling(ProcessingEnvironment processingEnvironment); static void clearTooling(); Elements getElements(); Filer getFiler(); Messager getMessager(); Types getTypes(); ProcessingEnvironment getProcessingEnvironment(); }### Answer:
@Test public void testToolingProviderSetToolingWithValidProcessingEnvironmentWithClear() { testToolingProviderSetToolingWithValidProcessingEnvironment(); ToolingProvider.clearTooling(); testToolingProviderSetToolingWithValidProcessingEnvironment(); } |
### Question:
UnaryOperationWrapperOperand extends Operand<Object> { @Override public Object value() { if (resultOperand == null) { calculateResultOperand(); } return resultOperand.value(); } UnaryOperationWrapperOperand(Operand operand, OperationType unaryOperationType); @Override Class<Object> getOperandsJavaType(); @Override Object value(); @Override OperandType getOperandType(); }### Answer:
@Test public void test_unaryOperationType_successfulPath_getValue() { UnaryOperationWrapperOperand unit = new UnaryOperationWrapperOperand(new BooleanOperand("true"), OperationType.NEGATE); MatcherAssert.assertThat((Boolean) unit.value(), Matchers.is(false)); unit = new UnaryOperationWrapperOperand(new BooleanOperand("false"), OperationType.NEGATE); MatcherAssert.assertThat((Boolean) unit.value(), Matchers.is(true)); }
@Test(expected = IllegalArgumentException.class) public void test_nullValuedOperand_mustThrowException() { UnaryOperationWrapperOperand unit = new UnaryOperationWrapperOperand(null, OperationType.NEGATE); MatcherAssert.assertThat(unit.value(), Matchers.nullValue()); } |
### Question:
UnaryOperationWrapperOperand extends Operand<Object> { @Override public Class<Object> getOperandsJavaType() { if (resultOperand == null) { calculateResultOperand(); } return resultOperand.getOperandsJavaType(); } UnaryOperationWrapperOperand(Operand operand, OperationType unaryOperationType); @Override Class<Object> getOperandsJavaType(); @Override Object value(); @Override OperandType getOperandType(); }### Answer:
@Test public void test_unaryOperationType_successfulPath_getOperandsJavaType() { UnaryOperationWrapperOperand unit = new UnaryOperationWrapperOperand(new BooleanOperand("true"), OperationType.NEGATE); MatcherAssert.assertThat( (Class)unit.getOperandsJavaType(), Matchers.equalTo((Class)Boolean.class)); } |
### Question:
LongOperand extends ParsedOperand<Long> { @Override public Long value() { return Long.valueOf(getExpressionString()); } LongOperand(String expressionString); @Override Class<Long> getOperandsJavaType(); @Override Long value(); @Override OperandType getOperandType(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void test_passedNullValue() { new LongOperand(null).value(); }
@Test public void test_createLongOperand() { MatcherAssert.assertThat((Long) new LongOperand("6").value(), Matchers.is(6L)); MatcherAssert.assertThat((Long) new LongOperand("-6").value(), Matchers.is(-6L)); } |
### Question:
LongOperand extends ParsedOperand<Long> { @Override public Class<Long> getOperandsJavaType() { return Long.class; } LongOperand(String expressionString); @Override Class<Long> getOperandsJavaType(); @Override Long value(); @Override OperandType getOperandType(); }### Answer:
@Test public void test_getOperandsJavaType() { MatcherAssert.assertThat(new LongOperand("6").getOperandsJavaType(), Matchers.equalTo((Class) Long.class)); } |
### Question:
OperandFactory { public static Operand createOperand(OperandType operandType, String expressionString, OperationType[] unaryOperationsToBeApplied, Expression expression) { if ((operandType == null) || (expressionString == null)) { throw new IllegalArgumentException("operandType and expressionString must not be null"); } Operand operand = null; switch (operandType) { case BOOLEAN: { operand = new BooleanOperand(expressionString); break; } case LONG: { operand = new LongOperand(expressionString); break; } case DOUBLE: { operand = new DoubleOperand(expressionString); break; } case STRING: { operand = new StringOperand(expressionString); break; } case DYNAMIC_VALUE: { operand = new DynamicOperand(expressionString); break; } case EXPRESSION: { operand = new ExpressionOperand(expressionString, expression); break; } case NULL_VALUE: { operand = new NullValueOperand(expressionString); break; } default: throw new IllegalArgumentException("operandType " + operandType + " currently not implemented"); } if (unaryOperationsToBeApplied != null && unaryOperationsToBeApplied.length >= 1) { for (int i = unaryOperationsToBeApplied.length - 1; i >= 0; i--) { operand = OperandFactory.createUnaryOperand(operand, unaryOperationsToBeApplied[i]); } } return operand; } private OperandFactory(); static Operand createOperand(OperandType operandType, String expressionString, OperationType[] unaryOperationsToBeApplied, Expression expression); static OperationResultOperand createOperationResult(Class type, Object value); static UnaryOperationWrapperOperand createUnaryOperand(Operand operand, OperationType operationType); }### Answer:
@Test(expected = IllegalArgumentException.class) public void createOperand_nullValued_operandType() { OperandFactory.createOperand(null, "ABC", new OperationType[0], null); }
@Test(expected = IllegalArgumentException.class) public void createOperand_nullValued_expressionString() { OperandFactory.createOperand(OperandType.BOOLEAN, null, new OperationType[0], null); } |
### Question:
Operand { public abstract OperandType getOperandType(); Operand(); abstract OperandType getOperandType(); abstract Class<? extends T> getOperandsJavaType(); abstract T value(); static String getStringRepresentationOfOperandsJavaTypes(Operand[] operandsArray); }### Answer:
@Test(expected = IllegalArgumentException.class) public void OperandType_getOperand_testNullValue() { OperandType.getOperandType(null); }
@Test public void OperandType_getOperand_testLong() { MatcherAssert.assertThat(OperandType.getOperandType("1234"), Matchers.is(OperandType.LONG)); }
@Test public void OperandType_getOperand_testDouble() { MatcherAssert.assertThat(OperandType.getOperandType("12.34"), Matchers.is(OperandType.DOUBLE)); }
@Test public void OperandType_getOperand_testString() { MatcherAssert.assertThat(OperandType.getOperandType("'1234'"), Matchers.is(OperandType.STRING)); }
@Test public void OperandType_getOperand_testBoolean_true() { MatcherAssert.assertThat(OperandType.getOperandType("true"), Matchers.is(OperandType.BOOLEAN)); }
@Test public void OperandType_getOperand_testBoolean_false() { MatcherAssert.assertThat(OperandType.getOperandType("false"), Matchers.is(OperandType.BOOLEAN)); }
@Test public void OperandType_getOperand_testExpression() { MatcherAssert.assertThat(OperandType.getOperandType("abc.def.hij"), Matchers.is(OperandType.DYNAMIC_VALUE)); MatcherAssert.assertThat(OperandType.getOperandType("abc.def"), Matchers.is(OperandType.DYNAMIC_VALUE)); MatcherAssert.assertThat(OperandType.getOperandType("abc"), Matchers.is(OperandType.DYNAMIC_VALUE)); } |
### Question:
NullValueOperand extends ParsedOperand<Object> { @Override public Object value() { return null; } NullValueOperand(String expressionString); @Override Class<Object> getOperandsJavaType(); @Override Object value(); @Override OperandType getOperandType(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void test_passedNullValue() { new BooleanOperand(null).value(); }
@Test public void test_getValue() { MatcherAssert.assertThat(new NullValueOperand("null").value(), Matchers.nullValue()); } |
### Question:
NullValueOperand extends ParsedOperand<Object> { @Override public Class<Object> getOperandsJavaType() { return null; } NullValueOperand(String expressionString); @Override Class<Object> getOperandsJavaType(); @Override Object value(); @Override OperandType getOperandType(); }### Answer:
@Test public void test_getOperandsJavaType() { MatcherAssert.assertThat(new NullValueOperand("null").getOperandsJavaType(), Matchers.nullValue()); } |
### Question:
BooleanOperand extends ParsedOperand<Boolean> { @Override public Boolean value() { return Boolean.valueOf(getExpressionString()); } BooleanOperand(String expressionString); @Override Class<Boolean> getOperandsJavaType(); @Override Boolean value(); @Override OperandType getOperandType(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void test_passedNullValue() { new BooleanOperand(null).value(); }
@Test public void test_createBooleanOperand() { MatcherAssert.assertThat((Boolean) new BooleanOperand("true").value(), Matchers.is(true)); MatcherAssert.assertThat((Boolean) new BooleanOperand("false").value(), Matchers.is(false)); }
@Test public void test_nonBooleanValue() { MatcherAssert.assertThat((Boolean) new BooleanOperand("XYZ").value(), Matchers.is(false)); } |
### Question:
BooleanOperand extends ParsedOperand<Boolean> { @Override public Class<Boolean> getOperandsJavaType() { return Boolean.class; } BooleanOperand(String expressionString); @Override Class<Boolean> getOperandsJavaType(); @Override Boolean value(); @Override OperandType getOperandType(); }### Answer:
@Test public void test_getOperandsJavaType() { MatcherAssert.assertThat(new BooleanOperand("true").getOperandsJavaType(), Matchers.equalTo((Class) Boolean.class)); } |
### Question:
StringOperand extends ParsedOperand<String> { @Override public Class<String> getOperandsJavaType() { return String.class; } StringOperand(String expressionString); @Override Class<String> getOperandsJavaType(); @Override String value(); @Override OperandType getOperandType(); }### Answer:
@Test public void test_getOperandsJavaType() { MatcherAssert.assertThat(new StringOperand("'test'").getOperandsJavaType(), Matchers.equalTo((Class) String.class)); } |
### Question:
StringOperand extends ParsedOperand<String> { @Override public String value() { return internalValue; } StringOperand(String expressionString); @Override Class<String> getOperandsJavaType(); @Override String value(); @Override OperandType getOperandType(); }### Answer:
@Test public void testStringWithoutEscapes() { MatcherAssert.assertThat(new StringOperand("'ABC DEF'").value(), Matchers.is("ABC DEF")); MatcherAssert.assertThat(new StringOperand("' MatcherAssert.assertThat(new StringOperand("'A%§GS34234|||F'").value(), Matchers.is("A%§GS34234|||F")); }
@Test public void testStringWithEscapedQuotes() { MatcherAssert.assertThat(new StringOperand("'ABC\\' DEF'").value(), Matchers.is("ABC' DEF")); MatcherAssert.assertThat(new StringOperand("' }
@Test public void testNonMatchingStringPattern() { MatcherAssert.assertThat(new StringOperand("'ABC").value(), Matchers.nullValue()); MatcherAssert.assertThat(new StringOperand("ABC'").value(), Matchers.nullValue()); MatcherAssert.assertThat(new StringOperand("ABC").value(), Matchers.nullValue()); }
@Test @Ignore public void testStringWithEscapedEscapeChars() { MatcherAssert.assertThat(new StringOperand("'ABC\\\\ DEF'").value(), Matchers.is("ABC\\ DEF")); MatcherAssert.assertThat(new StringOperand("'ABC\\\\\\' DEF'").value(), Matchers.is("ABC\\' DEF")); } |
### Question:
DoubleOperand extends ParsedOperand<Double> { @Override public Double value() { return Double.valueOf(getExpressionString()); } DoubleOperand( String expressionString); @Override Class<Double> getOperandsJavaType(); @Override Double value(); @Override OperandType getOperandType(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void test_passedNullValue() { new DoubleOperand(null).value(); }
@Test public void test_createDoubleOperand() { MatcherAssert.assertThat((Double) new DoubleOperand("6.0").value(), Matchers.is(6.0)); MatcherAssert.assertThat((Double) new DoubleOperand("-6.0").value(), Matchers.is(-6.0)); } |
### Question:
DoubleOperand extends ParsedOperand<Double> { @Override public Class<Double> getOperandsJavaType() { return Double.class; } DoubleOperand( String expressionString); @Override Class<Double> getOperandsJavaType(); @Override Double value(); @Override OperandType getOperandType(); }### Answer:
@Test public void test_getOperandsJavaType() { MatcherAssert.assertThat(new DoubleOperand("6.0").getOperandsJavaType(), Matchers.equalTo((Class) Double.class)); } |
### Question:
ExpressionParser { public static OperationTypeSearchResult getOperationType(String expressionString, int index) { for (OperationType operationType : OperationType.getOperationsByOperationTypeMode(OperationTypeMode.BINARY)) { Matcher matcher = operationType.getOperationPattern().matcher(expressionString); if (matcher.find(index) && matcher.start() == index) { return new OperationTypeSearchResult(operationType, matcher.start(), matcher.end()); } } throw new IllegalArgumentException("Can't determine operation type for string : " + expressionString.substring(index)); } static Expression parseExpression(String expressionString, Map<String, Object> model); static ExpressionParseResult parseExpressionRecursively(String expressionString, boolean usedBrackets); static OperationTypeSearchResult getOperationType(String expressionString, int index); static OperandTypeSearchResult getOperandType(String expressionString, int index); }### Answer:
@Test(expected = IllegalArgumentException.class) public void getOperationType_operationTypeNotFound() { ExpressionParser.getOperationType(" == sdsadasda", 12); }
@Test public void getOperationType_getEquals() { assertOperationTypeSearchResult(ExpressionParser.getOperationType(" == sdsadasda", 0), 0, 8, OperationType.EQUAL); assertOperationTypeSearchResult(ExpressionParser.getOperationType(" == sdsadasda", 2), 2, 8, OperationType.EQUAL); } |
### Question:
ParseUtilities { public static String readResourceToString(String resourcefileName) throws IOException { InputStream inputStream = ParseUtilities.class.getResourceAsStream(resourcefileName); if (inputStream != null) { return readFromInputStream(inputStream); } else { throw new IllegalArgumentException("Can't open resource file '" + resourcefileName + "'"); } } static TemplateBlockBinder parseString(String templateString); static String readResourceToString(String resourcefileName); static String readFromInputStream(InputStream stream); static String trimContentString(String content); static Map<String, String> parseNamedAttributes(String attributeString); static Map<String, Object> extractModelFromString(Map<String, Object> outerModel, String modelString); static final Pattern DYNAMIC_TEXT_BLOCK_REGEX; }### Answer:
@Test public void readResourceToStringTest() throws Exception { final String EXPECTED_RESULT = "ABC" + System.lineSeparator() + "DEF" + System.lineSeparator() + "HIJ"; MatcherAssert.assertThat(ParseUtilities.readResourceToString("/ReadResourceToStringTest.txt"), Matchers.is(EXPECTED_RESULT)); } |
### Question:
ParseUtilities { public static String trimContentString(String content) { String tmpContentString = content; tmpContentString = tmpContentString.replaceFirst("^[ ]*?\n", ""); tmpContentString = tmpContentString.replaceAll("[ ]+$", ""); return tmpContentString; } static TemplateBlockBinder parseString(String templateString); static String readResourceToString(String resourcefileName); static String readFromInputStream(InputStream stream); static String trimContentString(String content); static Map<String, String> parseNamedAttributes(String attributeString); static Map<String, Object> extractModelFromString(Map<String, Object> outerModel, String modelString); static final Pattern DYNAMIC_TEXT_BLOCK_REGEX; }### Answer:
@Test public void trimContentString_trimContentString_Test() { MatcherAssert.assertThat(ParseUtilities.trimContentString(" \nabc"), Matchers.is("abc")); MatcherAssert.assertThat(ParseUtilities.trimContentString(" \n abc"), Matchers.is(" abc")); MatcherAssert.assertThat(ParseUtilities.trimContentString(" \n \nabc"), Matchers.is(" \nabc")); MatcherAssert.assertThat(ParseUtilities.trimContentString("\nabc"), Matchers.is("abc")); MatcherAssert.assertThat(ParseUtilities.trimContentString(" \nabc\n "), Matchers.is("abc\n")); MatcherAssert.assertThat(ParseUtilities.trimContentString(" \nabc\n"), Matchers.is("abc\n")); } |
### Question:
ParseUtilities { public static Map<String, String> parseNamedAttributes(String attributeString) { Map<String, String> attributeMap = new HashMap<>(); final String attributePatternString = "\\s*(\\w+)\\s*:\\s*'(.*?)'\\s*"; Pattern attributePattern = Pattern.compile("(" + attributePatternString + ")(?:,(\" + attributePatternString+ \"))*"); Matcher matcher = attributePattern.matcher(attributeString); if (matcher.matches()) { Pattern findPattern = Pattern.compile(attributePatternString); Matcher findMatcher = findPattern.matcher(attributeString); while (findMatcher.find()) { String attributeName = findMatcher.group(1); String attributeValue = findMatcher.group(2); attributeMap.put(attributeName, attributeValue); } } return attributeMap; } static TemplateBlockBinder parseString(String templateString); static String readResourceToString(String resourcefileName); static String readFromInputStream(InputStream stream); static String trimContentString(String content); static Map<String, String> parseNamedAttributes(String attributeString); static Map<String, Object> extractModelFromString(Map<String, Object> outerModel, String modelString); static final Pattern DYNAMIC_TEXT_BLOCK_REGEX; }### Answer:
@Test public void parseNamedAttributes_parseAttributes() { String stringToParse = " abc : '/val1' , def : 'v.a.l2',hij:'val 3' "; Map<String, String> map = ParseUtilities.parseNamedAttributes(stringToParse); MatcherAssert.assertThat(map.get("abc"), Matchers.is("/val1")); MatcherAssert.assertThat(map.get("def"), Matchers.is("v.a.l2")); MatcherAssert.assertThat(map.get("hij"), Matchers.is("val 3")); } |
### Question:
ForTemplateBlock implements TemplateBlock { @Override public TemplateBlockType getTemplateBlockType() { return TemplateBlockType.FOR; } ForTemplateBlock(String attributeString, String templateString); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> outerVariables); TemplateBlockBinder getBinder(); void setBinder(TemplateBlockBinder binder); String getLoopVariableName(); String getAccessPath(); String getTemplateString(); }### Answer:
@Test public void test_getTemplateBlockType() { MatcherAssert.assertThat(new ForTemplateBlock("test:abc.def", "DEF").getTemplateBlockType(), Matchers.is(TemplateBlockType.FOR)); } |
### Question:
IfTemplateBlock implements TemplateBlock { @Override public TemplateBlockType getTemplateBlockType() { return TemplateBlockType.IF; } IfTemplateBlock(String attributeString, String templateString); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> outerVariables); TemplateBlockBinder getBinder(); void setBinder(TemplateBlockBinder binder); String getAccessPath(); String getTemplateString(); }### Answer:
@Test public void test_getTemplateBlockType() { MatcherAssert.assertThat(new IfTemplateBlock("abc", "").getTemplateBlockType(), Matchers.is(TemplateBlockType.IF)); } |
### Question:
StaticTemplateBlock implements TemplateBlock { @Override public TemplateBlockType getTemplateBlockType() { return TemplateBlockType.STATIC; } StaticTemplateBlock(String content); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> variables); }### Answer:
@Test public void test_getTemplateBlockType() { MatcherAssert.assertThat(new StaticTemplateBlock("").getTemplateBlockType(), Matchers.is(TemplateBlockType.STATIC)); } |
### Question:
PlainTextTemplateBlock implements TemplateBlock { @Override public TemplateBlockType getTemplateBlockType() { return TemplateBlockType.PLAIN_TEXT; } PlainTextTemplateBlock(String content); @Override TemplateBlockType getTemplateBlockType(); String getContent(Map<String, Object> variables); }### Answer:
@Test public void test_getTemplateBlockType() { MatcherAssert.assertThat(new PlainTextTemplateBlock("").getTemplateBlockType(), Matchers.is(TemplateBlockType.PLAIN_TEXT)); } |
### Question:
VariableTextTemplateBlock implements TemplateBlock { @Override public TemplateBlockType getTemplateBlockType() { return TemplateBlockType.DYNAMIC_TEXT; } VariableTextTemplateBlock(String accessPath); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> variables); }### Answer:
@Test public void test_getTemplateBlockType() { MatcherAssert.assertThat(new VariableTextTemplateBlock("abc").getTemplateBlockType(), Matchers.is(TemplateBlockType.DYNAMIC_TEXT)); } |
### Question:
VariableTextTemplateBlock implements TemplateBlock { protected String getAccessPath() { return this.accessPath; } VariableTextTemplateBlock(String accessPath); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> variables); }### Answer:
@Test public void test_constructor_ValidAccessPath() { VariableTextTemplateBlock unit = new VariableTextTemplateBlock("abc"); MatcherAssert.assertThat(unit.getAccessPath(), Matchers.equalTo("abc")); } |
### Question:
VariableTextTemplateBlock implements TemplateBlock { @Override public String getContent(Map<String, Object> variables) { Expression expression = ExpressionParser.parseExpression(accessPath, variables); Operand result = expression.evaluateExpression(); return result.value() != null ? result.value().toString() : null; } VariableTextTemplateBlock(String accessPath); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> variables); }### Answer:
@Test(expected = InvalidPathException.class) public void test_getContent_invalidPath() { VariableTextTemplateBlock unit = new VariableTextTemplateBlock("abc"); Map<String,Object> model = new HashMap<String, Object>(); unit.getContent(model); }
@Test public void test_getContent_nullValuedValue() { VariableTextTemplateBlock unit = new VariableTextTemplateBlock("abc"); Map<String,Object> model = new HashMap<String, Object>(); model.put("abc", null); MatcherAssert.assertThat(unit.getContent(model), Matchers.nullValue()); }
@Test public void test_getContent_nonNullValuedValue() { VariableTextTemplateBlock unit = new VariableTextTemplateBlock("abc"); Map<String,Object> model = new HashMap<String, Object>(); model.put("abc", "ABC"); MatcherAssert.assertThat(unit.getContent(model), Matchers.equalTo("ABC")); } |
### Question:
TemplateBlockBinder implements TemplateBlock { @Override public TemplateBlockType getTemplateBlockType() { return TemplateBlockType.BINDER; } TemplateBlockBinder( String templateString); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> variables); void addTemplateBlock(TemplateBlock templateBlock); }### Answer:
@Test public void test_getTemplateBlockType() { MatcherAssert.assertThat(new TemplateBlockBinder("").getTemplateBlockType(), Matchers.is(TemplateBlockType.BINDER)); } |
### Question:
IncludeTemplateBlock implements TemplateBlock { @Override public TemplateBlockType getTemplateBlockType() { return TemplateBlockType.INCLUDE; } IncludeTemplateBlock(String attributeString, String modelDefinitionString); @Override TemplateBlockType getTemplateBlockType(); @Override String getContent(Map<String, Object> variables); String getModelDefinitionString(); String getTemplateResource(); String getTemplateString(); String getModelAccessPath(); }### Answer:
@Test public void test_getTemplateBlockType() { MatcherAssert.assertThat(new IncludeTemplateBlock("resource : '/IncludeTemplateBlockTest.tpl'", "").getTemplateBlockType(), Matchers.is(TemplateBlockType.INCLUDE)); } |
### Question:
TemplateProcessor { public static String processTemplate(String templateString, Map<String, Object> values) { TemplateBlockBinder binder = ParseUtilities.parseString(templateString); return binder.getContent(values); } static String processTemplate(String templateString, Map<String, Object> values); static String processTemplateResourceFile(String templateFileName, Map<String, Object> values); }### Answer:
@Test public void testTemplateString() { Map<String, Object> map = new HashMap<String, Object>(); map.put("test", "YEP"); MatcherAssert.assertThat(TemplateProcessor.processTemplate("${test}", map), Matchers.is("YEP")); } |
### Question:
TemplateProcessor { public static String processTemplateResourceFile(String templateFileName, Map<String, Object> values) { String templateString = null; try { templateString = ParseUtilities.readResourceToString(templateFileName); } catch (Exception e) { throw new IllegalArgumentException("Cannot open template file '" + templateFileName + "'", e); } return processTemplate(templateString, values); } static String processTemplate(String templateString, Map<String, Object> values); static String processTemplateResourceFile(String templateFileName, Map<String, Object> values); }### Answer:
@Test public void testTemplateFile() { Map<String, Object> map = new HashMap<String, Object>(); map.put("test", "YEP"); MatcherAssert.assertThat(TemplateProcessor.processTemplateResourceFile("/TestTemplateProcessorTemplateFile.tpl", map), Matchers.is("YEP")); }
@Test(expected = IllegalArgumentException.class) public void testTemplateFile_withNonExistingFile() { Map<String, Object> map = new HashMap<String, Object>(); map.put("test", "YEP"); TemplateProcessor.processTemplateResourceFile("/XXX.tpl", map); } |
### Question:
IsClassMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isClass(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingCase() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return true for class : ", CoreMatchers.IS_CLASS.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingClass_enum() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(IsClassMatcherTest.class); List<Element> enums = ElementUtils.AccessEnclosedElements.getEnclosedElementsOfKind(typeElement, ElementKind.ENUM); MatcherAssert.assertThat("Precondition: must have found a enum", enums.size() >= 1); MatcherAssert.assertThat("Should return false for enum : ", !CoreMatchers.IS_CLASS.getMatcher().check(enums.get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_CLASS.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsEnumMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isEnum(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingEnum() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(IsEnumMatcherTest.class); List<? extends Element> enumList = ElementUtils.AccessEnclosedElements.getEnclosedElementsByName(typeElement, "TestEnum"); MatcherAssert.assertThat("Precondition: must have found a enum", enumList.size() >= 1); MatcherAssert.assertThat("Should return true for enum : ", CoreMatchers.IS_ENUM.getMatcher().check(enumList.get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMisatchingEnum_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non enum : ", !CoreMatchers.IS_ENUM.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_ENUM.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByGenericTypeMatcher implements CriteriaMatcher<Element, GenericType> { @Override public String getStringRepresentationOfPassedCharacteristic(GenericType toGetStringRepresentationFor) { if (toGetStringRepresentationFor == null) { return null; } StringBuilder stringBuilder = new StringBuilder(); createStringRepresentationRecursively(stringBuilder, toGetStringRepresentationFor); return stringBuilder.toString(); } ByGenericTypeMatcher(); @Override boolean checkForMatchingCharacteristic(Element element, GenericType toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(GenericType toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_createStringRepresentationCorrectly() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { GenericType genericTypeToConvert = TypeUtils.Generics.createGenericType(Map.class, TypeUtils.Generics.createWildcardWithExtendsBound( TypeUtils.Generics.createGenericType(StringBuilder.class) ), TypeUtils.Generics.createGenericType( Comparator.class, TypeUtils.Generics.createWildcardWithSuperBound( TypeUtils.Generics.createGenericType( List.class, TypeUtils.Generics.createPureWildcard() ) ) ) ); MatcherAssert.assertThat(CoreMatchers.BY_GENERIC_TYPE.getMatcher().getStringRepresentationOfPassedCharacteristic(genericTypeToConvert), org.hamcrest.Matchers.is("java.util.Map<? extends java.lang.StringBuilder, java.util.Comparator<? super java.util.List<?>>>")); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsMethodMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isMethod(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingMethod() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(IsParameterMatcherTest.class); List<? extends Element> methods = ElementUtils.AccessEnclosedElements.getEnclosedElementsByName(typeElement, "testMethod"); MatcherAssert.assertThat("Precondition: found test method", methods.size() == 1); MatcherAssert.assertThat("Should return true for method : ", CoreMatchers.IS_METHOD.getMatcher().check(methods.get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingMethod() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non method : ", !CoreMatchers.IS_METHOD.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_METHOD.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
ByAnnotationMatcher implements CriteriaMatcher<Element, Class<? extends Annotation>> { @Override public String getStringRepresentationOfPassedCharacteristic(Class<? extends Annotation> toGetStringRepresentationFor) { return toGetStringRepresentationFor != null ? toGetStringRepresentationFor.getCanonicalName() : null; } @Override String getStringRepresentationOfPassedCharacteristic(Class<? extends Annotation> toGetStringRepresentationFor); @Override boolean checkForMatchingCharacteristic(Element element, Class<? extends Annotation> toCheckFor); }### Answer:
@Test public void test_getStringRepresentationOfPassedCharacteristic_happyPath() { MatcherAssert.assertThat("Should return cannonical class name of annotation class", unit.getStringRepresentationOfPassedCharacteristic(TestAnnotation.class).equals(TestAnnotation.class.getCanonicalName())); }
@Test public void test_getStringRepresentationOfPassedCharacteristic_passedNullValue() { MatcherAssert.assertThat("Should return null for null valued parameter", unit.getStringRepresentationOfPassedCharacteristic(null) == null); } |
### Question:
ByAnnotationMatcher implements CriteriaMatcher<Element, Class<? extends Annotation>> { @Override public boolean checkForMatchingCharacteristic(Element element, Class<? extends Annotation> toCheckFor) { return element != null && toCheckFor != null && element.getAnnotation(toCheckFor) != null; } @Override String getStringRepresentationOfPassedCharacteristic(Class<? extends Annotation> toGetStringRepresentationFor); @Override boolean checkForMatchingCharacteristic(Element element, Class<? extends Annotation> toCheckFor); }### Answer:
@Test public void test_checkForMatchingCharacteristic_match() { TestAnnotation annotation = Mockito.mock(TestAnnotation.class); Element element = Mockito.mock(Element.class); Mockito.when(element.getAnnotation(TestAnnotation.class)).thenReturn(annotation); MatcherAssert.assertThat("Should find match correctly", unit.checkForMatchingCharacteristic(element, TestAnnotation.class)); }
@Test public void test_checkForMatchingCharacteristic_mismatch() { TestAnnotation annotation = Mockito.mock(TestAnnotation.class); Element element = Mockito.mock(Element.class); Mockito.when(element.getAnnotation(TestAnnotation.class)).thenReturn(null); MatcherAssert.assertThat("Should find mismatch correctly", !unit.checkForMatchingCharacteristic(element, TestAnnotation.class)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedElement() { MatcherAssert.assertThat("Should retrun false in case of null valued element", !unit.checkForMatchingCharacteristic(null, TestAnnotation.class)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedAnnotationType() { Element element = Mockito.mock(Element.class); MatcherAssert.assertThat("Should retrun false in case of null valued annotation", !unit.checkForMatchingCharacteristic(element, null)); }
@Test public void test_checkForMatchingCharacteristic_nullValuedParameters() { MatcherAssert.assertThat("Should retrun false in case of null valued parameters", !unit.checkForMatchingCharacteristic(null, null)); } |
### Question:
ByParameterTypeFqnMatcher implements CriteriaMatcher<ExecutableElement, String[]> { @Override public String getStringRepresentationOfPassedCharacteristic(String[] toGetStringRepresentationFor) { if (toGetStringRepresentationFor != null) { StringBuilder stringBuilder = new StringBuilder("["); boolean isFirst = true; for (String element : toGetStringRepresentationFor) { if (isFirst) { isFirst = false; } else { stringBuilder.append(", "); } stringBuilder.append(element); } stringBuilder.append("]"); return stringBuilder.toString(); } else { return null; } } ByParameterTypeFqnMatcher(); @Override boolean checkForMatchingCharacteristic(ExecutableElement element, String[] toCheckFor); @Override String getStringRepresentationOfPassedCharacteristic(String[] toGetStringRepresentationFor); }### Answer:
@Test public void getStringRepresentationOfPassedCharacteristic_nullValue() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should not have found matching parameters", CoreMatchers.BY_PARAMETER_TYPE_FQN.getMatcher().getStringRepresentationOfPassedCharacteristic(null), Matchers.nullValue()); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void getStringRepresentationOfPassedCharacteristic_getStringRepreentation() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should have created valid string representation", CoreMatchers.BY_PARAMETER_TYPE_FQN.getMatcher().getStringRepresentationOfPassedCharacteristic(Utilities.convertVarargsToArray(String.class.getCanonicalName(), Boolean.class.getCanonicalName())), Matchers.is("[java.lang.String, java.lang.Boolean]")); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
IsParameterMatcher implements ImplicitMatcher<ELEMENT> { @Override public boolean check(ELEMENT element) { return ElementUtils.CheckKindOfElement.isParameter(element); } @Override boolean check(ELEMENT element); }### Answer:
@Test public void checkMatchingParameter() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { TypeElement typeElement = TypeUtils.TypeRetrieval.getTypeElement(IsParameterMatcherTest.class); List<? extends Element> methods = ElementUtils.AccessEnclosedElements.getEnclosedElementsByName(typeElement, "testMethod"); MatcherAssert.assertThat("Precondition: found test method", methods.size() == 1); ExecutableElement testMethod = (ExecutableElement) methods.get(0); MatcherAssert.assertThat("Precondition: found at least one parameter", ((ExecutableElement) methods.get(0)).getParameters().size() >= 1); MatcherAssert.assertThat("Should return true for parameter : ", CoreMatchers.IS_PARAMETER.getMatcher().check(testMethod.getParameters().get(0))); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkMismatchingParameter_class() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for non parameter : ", !CoreMatchers.IS_PARAMETER.getMatcher().check(element)); } }) .compilationShouldSucceed() .executeTest(); }
@Test public void checkNullValuedElement() { unitTestBuilder.useProcessor(new AbstractUnitTestAnnotationProcessorClass() { @Override protected void testCase(TypeElement element) { MatcherAssert.assertThat("Should return false for null valued element : ", !CoreMatchers.IS_PARAMETER.getMatcher().check(null)); } }) .compilationShouldSucceed() .executeTest(); } |
### Question:
TimerPresenter implements TimerActivityContract.UserActionsListener { @Override public void setTimer() { timer.set(calendar.getTimeInMillis()); view.close(); } TimerPresenter(Context context, DateFormat formatter, boolean is24HourFormat, Timer timer, TimerActivityContract.View view); @Override void setTimer(); @Override void cancelTimer(); @Override void undoTimer(); @Override void increaseTimerHour(); @Override void decreaseTimerHour(); @Override void increaseTimerMinute(); @Override void decreaseTimerMinute(); @Override void switchAmPm(); @Override void updateTime(); @Override void setupTitle(String timerMode); @Override long getTime(); @Override void setTime(long time); long getTimerDuration(); static void roundTimeUp(Calendar calendar); void setCalendar(Calendar calendar); static final int MINUTE_INCREMENT; static final int MINIMUM_INCREMENT; static final long TIME_INVALID; }### Answer:
@Test public void setTimer_shouldSetTimerAndCloseView() { presenter.setTimer(); verify(timer).set(testCalendarPm.getTimeInMillis()); verify(view).close(); } |
### Question:
TimerPresenter implements TimerActivityContract.UserActionsListener { @Override public long getTime() { return calendar.getTimeInMillis(); } TimerPresenter(Context context, DateFormat formatter, boolean is24HourFormat, Timer timer, TimerActivityContract.View view); @Override void setTimer(); @Override void cancelTimer(); @Override void undoTimer(); @Override void increaseTimerHour(); @Override void decreaseTimerHour(); @Override void increaseTimerMinute(); @Override void decreaseTimerMinute(); @Override void switchAmPm(); @Override void updateTime(); @Override void setupTitle(String timerMode); @Override long getTime(); @Override void setTime(long time); long getTimerDuration(); static void roundTimeUp(Calendar calendar); void setCalendar(Calendar calendar); static final int MINUTE_INCREMENT; static final int MINIMUM_INCREMENT; static final long TIME_INVALID; }### Answer:
@Test public void getTime_shouldReturnTimeInMillis() { assertThat(presenter.getTime(), is(testCalendarPm.getTimeInMillis())); } |
### Question:
TimerPresenter implements TimerActivityContract.UserActionsListener { public long getTimerDuration() { long now = System.currentTimeMillis(); return (calendar.getTimeInMillis() - now) / MINUTE_IN_MILLIS; } TimerPresenter(Context context, DateFormat formatter, boolean is24HourFormat, Timer timer, TimerActivityContract.View view); @Override void setTimer(); @Override void cancelTimer(); @Override void undoTimer(); @Override void increaseTimerHour(); @Override void decreaseTimerHour(); @Override void increaseTimerMinute(); @Override void decreaseTimerMinute(); @Override void switchAmPm(); @Override void updateTime(); @Override void setupTitle(String timerMode); @Override long getTime(); @Override void setTime(long time); long getTimerDuration(); static void roundTimeUp(Calendar calendar); void setCalendar(Calendar calendar); static final int MINUTE_INCREMENT; static final int MINIMUM_INCREMENT; static final long TIME_INVALID; }### Answer:
@Test public void getTimerDuration() { long now = System.currentTimeMillis(); long duration = presenter.getTimerDuration(); assertThat(duration, is((presenter.getTime() - now) / MINUTE_IN_MILLIS)); } |
### Question:
TimerPresenter implements TimerActivityContract.UserActionsListener { @Override public void cancelTimer() { timer.cancel(); view.close(); } TimerPresenter(Context context, DateFormat formatter, boolean is24HourFormat, Timer timer, TimerActivityContract.View view); @Override void setTimer(); @Override void cancelTimer(); @Override void undoTimer(); @Override void increaseTimerHour(); @Override void decreaseTimerHour(); @Override void increaseTimerMinute(); @Override void decreaseTimerMinute(); @Override void switchAmPm(); @Override void updateTime(); @Override void setupTitle(String timerMode); @Override long getTime(); @Override void setTime(long time); long getTimerDuration(); static void roundTimeUp(Calendar calendar); void setCalendar(Calendar calendar); static final int MINUTE_INCREMENT; static final int MINIMUM_INCREMENT; static final long TIME_INVALID; }### Answer:
@Test public void cancelTimer_shouldCancelTimerAndCloseView() { presenter.cancelTimer(); verify(timer).cancel(); verify(view).close(); } |
### Question:
TimerPresenter implements TimerActivityContract.UserActionsListener { @Override public void undoTimer() { timer.cancel(); view.undoWifiState(); view.close(); } TimerPresenter(Context context, DateFormat formatter, boolean is24HourFormat, Timer timer, TimerActivityContract.View view); @Override void setTimer(); @Override void cancelTimer(); @Override void undoTimer(); @Override void increaseTimerHour(); @Override void decreaseTimerHour(); @Override void increaseTimerMinute(); @Override void decreaseTimerMinute(); @Override void switchAmPm(); @Override void updateTime(); @Override void setupTitle(String timerMode); @Override long getTime(); @Override void setTime(long time); long getTimerDuration(); static void roundTimeUp(Calendar calendar); void setCalendar(Calendar calendar); static final int MINUTE_INCREMENT; static final int MINIMUM_INCREMENT; static final long TIME_INVALID; }### Answer:
@Test public void undoTimer_shouldRestoreWifiStateAndCloseView() { presenter.undoTimer(); verify(timer).cancel(); verify(view).undoWifiState(); verify(view).close(); } |
### Question:
TimerPresenter implements TimerActivityContract.UserActionsListener { @Override public void setupTitle(String timerMode) { if (AppConfig.MODE_ON_WIFI_ACTIVATION.equals(timerMode)) { view.setDialogTitle(R.string.instructions_on_wifi_activation); } else { view.setDialogTitle(R.string.instructions_on_wifi_deactivation); } } TimerPresenter(Context context, DateFormat formatter, boolean is24HourFormat, Timer timer, TimerActivityContract.View view); @Override void setTimer(); @Override void cancelTimer(); @Override void undoTimer(); @Override void increaseTimerHour(); @Override void decreaseTimerHour(); @Override void increaseTimerMinute(); @Override void decreaseTimerMinute(); @Override void switchAmPm(); @Override void updateTime(); @Override void setupTitle(String timerMode); @Override long getTime(); @Override void setTime(long time); long getTimerDuration(); static void roundTimeUp(Calendar calendar); void setCalendar(Calendar calendar); static final int MINUTE_INCREMENT; static final int MINIMUM_INCREMENT; static final long TIME_INVALID; }### Answer:
@Test public void setupTitle_shouldSetTitleWithDeactivationMode() { presenter.setupTitle(AppConfig.MODE_ON_WIFI_DEACTIVATION); verify(view).setDialogTitle(R.string.instructions_on_wifi_deactivation); }
@Test public void setupTitle_shouldSetTitleWithActivationMode() { presenter.setupTitle(AppConfig.MODE_ON_WIFI_ACTIVATION); verify(view).setDialogTitle(R.string.instructions_on_wifi_activation); }
@Test public void setupTitle_shouldHandleInvalidMode() { presenter.setupTitle(null); verify(view).setDialogTitle(R.string.instructions_on_wifi_deactivation); } |
### Question:
ProblemInjector implements ProblemInterceptor { public void handleRequest(final Request request) { for (ProblemInterceptorSupport interceptor : interceptorChain) { if (interceptor.isInjectProblem(request)) { interceptor.handleRequest(request); } } } ProblemInjector(); ProblemInjector(List<ProblemInterceptorSupport> chain); void handleRequest(final Request request); static final String ISSUE_HEADER; }### Answer:
@Test public void handlerInvokedTest() throws Exception { when(request.getHeader(ProblemInjector.ISSUE_HEADER)).thenReturn("myError, otherError"); injector.handleRequest(request); verify(myProblemInterceptor).handleRequest(request); }
@Test public void handlerNotInvokedTest() throws Exception { when(request.getHeader(ProblemInjector.ISSUE_HEADER)).thenReturn("otherError"); injector.handleRequest(request); verify(myProblemInterceptor, never()).handleRequest(request); } |
### Question:
BookingServiceImpl implements BookingService { @Override public void cancelBooking(String user, String bookingId) { try { bookingRepository.delete(bookingId); } catch (Exception e) { throw new RuntimeException(e); } } String bookFlight(String customerId, String flightId); @Override String bookFlight(String customerId, String flightSegmentId, String flightId); @Override Booking getBooking(String user, String bookingId); @Override List<Booking> getBookingsByUser(String user); @Override void cancelBooking(String user, String bookingId); @Override Long count(); }### Answer:
@Test public void deletesBookingWhenCancelled() { bookingService.cancelBooking(booking.getCustomerId(), booking.getBookingId()); verify(bookingRepository).delete(booking.getBookingId()); } |
### Question:
BookingServiceImpl implements BookingService { public String bookFlight(String customerId, String flightId) { try { Flight f = flightService.getFlightByFlightId(flightId, null); CustomerInfo customerInfo = userService.getCustomerInfo(customerId); BookingImpl newBooking = new BookingImpl(keyGenerator.generate().toString(), new Date(), customerInfo, f); bookingRepository.save(newBooking); return newBooking.getBookingId(); } catch (Exception e) { throw new RuntimeException(e); } } String bookFlight(String customerId, String flightId); @Override String bookFlight(String customerId, String flightSegmentId, String flightId); @Override Booking getBooking(String user, String bookingId); @Override List<Booking> getBookingsByUser(String user); @Override void cancelBooking(String user, String bookingId); @Override Long count(); }### Answer:
@Test public void getsBookingIdWhenFlightsBooked() { when(flightService.getFlightByFlightId(booking.getFlightId(), null)).thenReturn(flight); when(userService.getCustomerInfo(booking.getCustomerId())).thenReturn(customer); String bookingId = bookingService.bookFlight( booking.getCustomerId(), uniquify("flightSegmentId"), booking.getFlightId() ); assertThat(bookingId, is(booking.getBookingId())); } |
### Question:
BookingServiceImpl implements BookingService { @Override public List<Booking> getBookingsByUser(String user) { try { List<BookingImpl> bookingImpls = bookingRepository.findByCustomerId(user); List<Booking> bookings = new ArrayList<Booking>(); for (Booking b : bookingImpls) { bookings.add(b); } return bookings; } catch (Exception e) { throw new RuntimeException(e); } } String bookFlight(String customerId, String flightId); @Override String bookFlight(String customerId, String flightSegmentId, String flightId); @Override Booking getBooking(String user, String bookingId); @Override List<Booking> getBookingsByUser(String user); @Override void cancelBooking(String user, String bookingId); @Override Long count(); }### Answer:
@Test public void getsBookingOfSpecifiedUser() { when(bookingRepository.findByCustomerId(booking.getCustomerId())).thenReturn(singletonList(booking)); List<Booking> bookings = bookingService.getBookingsByUser(booking.getCustomerId()); assertThat(bookings, contains(booking)); } |
### Question:
UserCommand implements UserService { @HystrixCommand public CustomerInfo getCustomerInfo(String customerId) { String address = getCustomerServiceAddress(); log.info("Sending GET request to remote customer at {} with customer id {}", address, customerId); ResponseEntity<CustomerInfo> resp = restTemplate.getForEntity(address + "/api/customer/{custid}", CustomerInfo.class, customerId); if (resp.getStatusCode() != HttpStatus.OK) { throw new NoSuchElementException("No such customer with id " + customerId); } log.info("Received response {} from remote customer at {} with customer id {}", resp.getBody(), address, customerId); return resp.getBody(); } UserCommand(RestTemplate restTemplate); @HystrixCommand CustomerInfo getCustomerInfo(String customerId); }### Answer:
@Test @PactVerification public void fetchesExpectedCustomer() throws IOException { CustomerInfo actual = userService.getCustomerInfo(customerInfo.getId()); assertThat(actual, is(customerInfo)); } |
### Question:
LoginCookieUpdateFilter extends ZuulFilter { @Override public boolean shouldFilter() { RequestContext ctx = RequestContext.getCurrentContext(); return ctx.getRequest().getRequestURI().endsWith("/api/login") && ctx.getResponseStatusCode() == 200 && ctx.getResponse().getHeader(SET_COOKIE) == null; } @Override String filterType(); @Override int filterOrder(); @Override boolean shouldFilter(); @Override Object run(); }### Answer:
@Test public void skippedPathNotEndsWithLogin() { context.setResponseStatusCode(200); when(response.getHeader(SET_COOKIE)).thenReturn(null); when(request.getRequestURI()).thenReturn("/login"); assertThat(this.filter.shouldFilter(), is(false)); when(request.getRequestURI()).thenReturn("/api/login/validate"); assertThat(this.filter.shouldFilter(), is(false)); when(request.getRequestURI()).thenReturn("/api/login/"); assertThat(this.filter.shouldFilter(), is(false)); }
@Test public void skippedWhenStatusIsNot200() { when(response.getHeader(SET_COOKIE)).thenReturn(null); when(request.getRequestURI()).thenReturn("/api/login"); when(response.getStatus()).thenReturn(404); assertThat(this.filter.shouldFilter(), is(false)); }
@Test public void skippedWhenCookieHeaderIsNotNull() { context.setResponseStatusCode(200); when(request.getRequestURI()).thenReturn("/api/login"); when(response.getHeader(SET_COOKIE)).thenReturn("sessionid=abc"); assertThat(this.filter.shouldFilter(), is(false)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.