| package org.checkerframework.checker.testchecker.lubglb; |
| |
| // Test case for issues 691 and 756. |
| // https://github.com/typetools/checker-framework/issues/691 |
| // https://github.com/typetools/checker-framework/issues/756 |
| |
| import java.lang.annotation.Annotation; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.Set; |
| import javax.lang.model.element.AnnotationMirror; |
| import javax.lang.model.util.Elements; |
| import org.checkerframework.checker.formatter.FormatterAnnotatedTypeFactory; |
| import org.checkerframework.checker.formatter.FormatterChecker; |
| import org.checkerframework.checker.formatter.FormatterTreeUtil; |
| import org.checkerframework.checker.formatter.FormatterVisitor; |
| import org.checkerframework.checker.formatter.qual.ConversionCategory; |
| import org.checkerframework.checker.formatter.qual.Format; |
| import org.checkerframework.checker.formatter.qual.FormatBottom; |
| import org.checkerframework.checker.formatter.qual.InvalidFormat; |
| import org.checkerframework.checker.formatter.qual.UnknownFormat; |
| import org.checkerframework.common.basetype.BaseTypeChecker; |
| import org.checkerframework.common.basetype.BaseTypeVisitor; |
| import org.checkerframework.framework.type.QualifierHierarchy; |
| import org.checkerframework.javacutil.AnnotationBuilder; |
| import org.checkerframework.javacutil.AnnotationUtils; |
| |
| /** |
| * This class tests the implementation of GLB computation in the Formatter Checker, but it does not |
| * test for the crash described in issue 691. That is done by tests/all-systems/Issue691.java. It |
| * also tests the implementation of LUB computation in the Formatter Checker. |
| */ |
| public class FormatterLubGlbChecker extends FormatterChecker { |
| |
| @Override |
| protected BaseTypeVisitor<?> createSourceVisitor() { |
| return new FormatterVisitor(this) { |
| @Override |
| protected FormatterLubGlbAnnotatedTypeFactory createTypeFactory() { |
| return new FormatterLubGlbAnnotatedTypeFactory(checker); |
| } |
| }; |
| } |
| |
| /** FormatterLubGlbAnnotatedTypeFactory. */ |
| private static class FormatterLubGlbAnnotatedTypeFactory extends FormatterAnnotatedTypeFactory { |
| |
| /** |
| * Constructor. |
| * |
| * @param checker checker |
| */ |
| public FormatterLubGlbAnnotatedTypeFactory(BaseTypeChecker checker) { |
| super(checker); |
| postInit(); |
| } |
| |
| @Override |
| protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() { |
| return new HashSet<>( |
| Arrays.asList( |
| FormatBottom.class, Format.class, InvalidFormat.class, UnknownFormat.class)); |
| } |
| } |
| |
| @SuppressWarnings("checkstyle:localvariablename") |
| @Override |
| public void initChecker() { |
| super.initChecker(); |
| FormatterTreeUtil treeUtil = new FormatterTreeUtil(this); |
| |
| Elements elements = getElementUtils(); |
| AnnotationMirror UNKNOWNFORMAT = AnnotationBuilder.fromClass(elements, UnknownFormat.class); |
| AnnotationMirror FORMAT = |
| AnnotationBuilder.fromClass( |
| elements, |
| Format.class, |
| AnnotationBuilder.elementNamesValues("value", new ConversionCategory[0])); |
| AnnotationMirror INVALIDFORMAT = |
| AnnotationBuilder.fromClass( |
| elements, InvalidFormat.class, AnnotationBuilder.elementNamesValues("value", "dummy")); |
| AnnotationMirror FORMATBOTTOM = AnnotationBuilder.fromClass(elements, FormatBottom.class); |
| |
| AnnotationBuilder builder = new AnnotationBuilder(processingEnv, InvalidFormat.class); |
| builder.setValue("value", "Message"); |
| AnnotationMirror invalidFormatWithMessage = builder.build(); |
| |
| builder = new AnnotationBuilder(processingEnv, InvalidFormat.class); |
| builder.setValue("value", "Message2"); |
| AnnotationMirror invalidFormatWithMessage2 = builder.build(); |
| |
| builder = new AnnotationBuilder(processingEnv, InvalidFormat.class); |
| builder.setValue("value", "(\"Message\" or \"Message2\")"); |
| AnnotationMirror invalidFormatWithMessagesOred = builder.build(); |
| |
| builder = new AnnotationBuilder(processingEnv, InvalidFormat.class); |
| builder.setValue("value", "(\"Message\" and \"Message2\")"); |
| AnnotationMirror invalidFormatWithMessagesAnded = builder.build(); |
| |
| ConversionCategory[] cc = new ConversionCategory[1]; |
| |
| cc[0] = ConversionCategory.UNUSED; |
| AnnotationMirror formatUnusedAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.GENERAL; |
| AnnotationMirror formatGeneralAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.CHAR; |
| AnnotationMirror formatCharAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.INT; |
| AnnotationMirror formatIntAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.TIME; |
| AnnotationMirror formatTimeAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.FLOAT; |
| AnnotationMirror formatFloatAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.CHAR_AND_INT; |
| AnnotationMirror formatCharAndIntAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.INT_AND_TIME; |
| AnnotationMirror formatIntAndTimeAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| cc[0] = ConversionCategory.NULL; |
| AnnotationMirror formatNullAnno = treeUtil.categoriesToFormatAnnotation(cc); |
| |
| QualifierHierarchy qh = ((BaseTypeVisitor<?>) visitor).getTypeFactory().getQualifierHierarchy(); |
| |
| // ** GLB tests ** |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatIntAndTimeAnno), formatIntAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(INT_AND_TIME) is not @Format(INT)!"; |
| |
| // GLB of UNUSED and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatGeneralAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(GENERAL) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatCharAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(CHAR) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatIntAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(INT) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatTimeAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(TIME) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatFloatAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(FLOAT) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatCharAndIntAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(CHAR_AND_INT) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatIntAndTimeAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(INT_AND_TIME) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatNullAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(NULL) is not @Format(UNUSED)!"; |
| |
| // GLB of GENERAL and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(GENERAL) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatCharAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(CHAR) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatIntAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(INT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatFloatAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(FLOAT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatCharAndIntAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(CHAR_AND_INT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatIntAndTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(INT_AND_TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatNullAnno), formatGeneralAnno) |
| : "GLB of @Format(GENERAL) and @Format(NULL) is not @Format(GENERAL)!"; |
| |
| // GLB of CHAR and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(CHAR) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatCharAnno), formatCharAnno) |
| : "GLB of @Format(CHAR) and @Format(CHAR) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatIntAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR) and @Format(INT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR) and @Format(TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatFloatAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR) and @Format(FLOAT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatCharAndIntAnno), formatCharAnno) |
| : "GLB of @Format(CHAR) and @Format(CHAR_AND_INT) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatIntAndTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR) and @Format(INT_AND_TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAnno, formatNullAnno), formatCharAnno) |
| : "GLB of @Format(CHAR) and @Format(NULL) is not @Format(CHAR)!"; |
| |
| // GLB of INT and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(INT) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(INT) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatCharAnno), formatGeneralAnno) |
| : "GLB of @Format(INT) and @Format(CHAR) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatIntAnno), formatIntAnno) |
| : "GLB of @Format(INT) and @Format(INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(INT) and @Format(TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatFloatAnno), formatGeneralAnno) |
| : "GLB of @Format(INT) and @Format(FLOAT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatCharAndIntAnno), formatIntAnno) |
| : "GLB of @Format(INT) and @Format(CHAR_AND_INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatIntAndTimeAnno), formatIntAnno) |
| : "GLB of @Format(INT) and @Format(INT_AND_TIME) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAnno, formatNullAnno), formatIntAnno) |
| : "GLB of @Format(INT) and @Format(NULL) is not @Format(INT)!"; |
| |
| // GLB of TIME and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(TIME) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(TIME) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatCharAnno), formatGeneralAnno) |
| : "GLB of @Format(TIME) and @Format(CHAR) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatIntAnno), formatGeneralAnno) |
| : "GLB of @Format(TIME) and @Format(INT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatTimeAnno), formatTimeAnno) |
| : "GLB of @Format(TIME) and @Format(TIME) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatFloatAnno), formatGeneralAnno) |
| : "GLB of @Format(TIME) and @Format(FLOAT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatCharAndIntAnno), formatGeneralAnno) |
| : "GLB of @Format(TIME) and @Format(CHAR_AND_INT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatIntAndTimeAnno), formatTimeAnno) |
| : "GLB of @Format(TIME) and @Format(INT_AND_TIME) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTimeAnno, formatNullAnno), formatTimeAnno) |
| : "GLB of @Format(TIME) and @Format(NULL) is not @Format(TIME)!"; |
| |
| // GLB of FLOAT and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(FLOAT) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(FLOAT) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatCharAnno), formatGeneralAnno) |
| : "GLB of @Format(FLOAT) and @Format(CHAR) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatIntAnno), formatGeneralAnno) |
| : "GLB of @Format(FLOAT) and @Format(INT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(FLOAT) and @Format(TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatFloatAnno), formatFloatAnno) |
| : "GLB of @Format(FLOAT) and @Format(FLOAT) is not @Format(FLOAT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatCharAndIntAnno), formatGeneralAnno) |
| : "GLB of @Format(FLOAT) and @Format(CHAR_AND_INT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatIntAndTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(FLOAT) and @Format(INT_AND_TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatFloatAnno, formatNullAnno), formatFloatAnno) |
| : "GLB of @Format(FLOAT) and @Format(NULL) is not @Format(FLOAT)!"; |
| |
| // GLB of CHAR_AND_INT and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatCharAnno), formatCharAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(CHAR) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatIntAnno), formatIntAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatTimeAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(TIME) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatFloatAnno), formatGeneralAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(FLOAT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatCharAndIntAnno), formatCharAndIntAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(CHAR_AND_INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatIntAndTimeAnno), formatIntAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(INT_AND_TIME) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatCharAndIntAnno, formatNullAnno), formatCharAndIntAnno) |
| : "GLB of @Format(CHAR_AND_INT) and @Format(NULL) is not @Format(CHAR_AND_INT)!"; |
| |
| // GLB of INT_AND_TIME and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatCharAnno), formatGeneralAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(CHAR) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatIntAnno), formatIntAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatTimeAnno), formatTimeAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(TIME) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatFloatAnno), formatGeneralAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(FLOAT) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatCharAndIntAnno), formatIntAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(CHAR_AND_INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatIntAndTimeAnno), formatIntAndTimeAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(INT_AND_TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatIntAndTimeAnno, formatNullAnno), formatIntAndTimeAnno) |
| : "GLB of @Format(INT_AND_TIME) and @Format(NULL) is not @Format(INT_AND_TIME)!"; |
| |
| // GLB of NULL and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(NULL) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatGeneralAnno), formatGeneralAnno) |
| : "GLB of @Format(NULL) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatCharAnno), formatCharAnno) |
| : "GLB of @Format(NULL) and @Format(CHAR) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatIntAnno), formatIntAnno) |
| : "GLB of @Format(NULL) and @Format(INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatTimeAnno), formatTimeAnno) |
| : "GLB of @Format(NULL) and @Format(TIME) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatFloatAnno), formatFloatAnno) |
| : "GLB of @Format(NULL) and @Format(FLOAT) is not @Format(FLOAT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatCharAndIntAnno), formatCharAndIntAnno) |
| : "GLB of @Format(NULL) and @Format(CHAR_AND_INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatIntAndTimeAnno), formatIntAndTimeAnno) |
| : "GLB of @Format(NULL) and @Format(INT_AND_TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatNullAnno, formatNullAnno), formatNullAnno) |
| : "GLB of @Format(NULL) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // Now test with two ConversionCategory at a time: |
| |
| ConversionCategory[] cc2 = new ConversionCategory[2]; |
| |
| cc2[0] = ConversionCategory.CHAR_AND_INT; |
| cc2[1] = ConversionCategory.FLOAT; |
| AnnotationMirror formatTwoConvCat1 = treeUtil.categoriesToFormatAnnotation(cc2); |
| cc2[0] = ConversionCategory.INT; |
| cc2[1] = ConversionCategory.CHAR; |
| AnnotationMirror formatTwoConvCat2 = treeUtil.categoriesToFormatAnnotation(cc2); |
| cc2[0] = ConversionCategory.INT; |
| cc2[1] = ConversionCategory.GENERAL; |
| AnnotationMirror formatTwoConvCat3 = treeUtil.categoriesToFormatAnnotation(cc2); |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTwoConvCat1, formatTwoConvCat2), formatTwoConvCat3) |
| : "GLB of @Format([CHAR_AND_INT,FLOAT]) and @Format([INT,CHAR]) is not" |
| + " @Format([INT,GENERAL])!"; |
| |
| // Test that the GLB of two ConversionCategory arrays of different sizes is an array of the |
| // smallest size of the two: |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatGeneralAnno, formatTwoConvCat1), formatGeneralAnno) |
| : "GLB of @I18nFormat(GENERAL) and @I18nFormat([CHAR_AND_INT,FLOAT]) is not" |
| + " @I18nFormat(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatTwoConvCat2, formatNullAnno), formatIntAnno) |
| : "GLB of @I18nFormat([INT,CHAR]) and @I18nFormat(NULL) is not @I18nFormat(INT)!"; |
| |
| // GLB of @UnknownFormat and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(UNKNOWNFORMAT, UNKNOWNFORMAT), UNKNOWNFORMAT) |
| : "GLB of @UnknownFormat and @UnknownFormat is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(UNKNOWNFORMAT, FORMAT), FORMAT) |
| : "GLB of @UnknownFormat and @Format(null) is not @Format(null)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(UNKNOWNFORMAT, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @UnknownFormat and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(UNKNOWNFORMAT, INVALIDFORMAT), INVALIDFORMAT) |
| : "GLB of @UnknownFormat and @InvalidFormat(null) is not @InvalidFormat(null)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(UNKNOWNFORMAT, invalidFormatWithMessage), |
| invalidFormatWithMessage) |
| : "GLB of @UnknownFormat and @InvalidFormat(\"Message\") is not" |
| + " @InvalidFormat(\"Message\")!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(UNKNOWNFORMAT, FORMATBOTTOM), FORMATBOTTOM) |
| : "GLB of @UnknownFormat and @FormatBottom is not @FormatBottom!"; |
| |
| // GLB of @Format(null) and others |
| |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(FORMAT, UNKNOWNFORMAT), FORMAT) |
| : "GLB of @Format(null) and @UnknownFormat is not @Format(null)!"; |
| // Computing the GLB of @Format(null) and @Format(null) should never occur in practice. |
| // Skipping this case as it causes an expected crash. |
| // Computing the GLB of @Format(null) and @Format with a value should never occur in |
| // practice. Skipping this case as it causes an expected crash. |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(FORMAT, INVALIDFORMAT), FORMATBOTTOM) |
| : "GLB of @Format(null) and @InvalidFormat(null) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(FORMAT, invalidFormatWithMessage), FORMATBOTTOM) |
| : "GLB of @Format(null) and @InvalidFormat(\"Message\") is not @FormatBottom!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(FORMAT, FORMATBOTTOM), FORMATBOTTOM) |
| : "GLB of @Format(null) and @FormatBottom is not @FormatBottom!"; |
| |
| // GLB of @Format(UNUSED) and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, UNKNOWNFORMAT), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @UnknownFormat is not @Format(UNUSED)!"; |
| // Computing the GLB of @Format with a value and @Format(null) should never occur in |
| // practice. Skipping this case as it causes an expected crash. |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, formatUnusedAnno), formatUnusedAnno) |
| : "GLB of @Format(UNUSED) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, INVALIDFORMAT), FORMATBOTTOM) |
| : "GLB of @Format(UNUSED) and @InvalidFormat(null) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, invalidFormatWithMessage), FORMATBOTTOM) |
| : "GLB of @Format(UNUSED) and @InvalidFormat(\"Message\") is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(formatUnusedAnno, FORMATBOTTOM), FORMATBOTTOM) |
| : "GLB of @Format(UNUSED) and @FormatBottom is not @FormatBottom!"; |
| |
| // GLB of @InvalidFormat(null) and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(INVALIDFORMAT, UNKNOWNFORMAT), INVALIDFORMAT) |
| : "GLB of @InvalidFormat(null) and @UnknownFormat is not @InvalidFormat(null)!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(INVALIDFORMAT, FORMAT), FORMATBOTTOM) |
| : "GLB of @InvalidFormat(null) and @Format(null) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(INVALIDFORMAT, formatUnusedAnno), FORMATBOTTOM) |
| : "GLB of @InvalidFormat(null) and @Format(UNUSED) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(INVALIDFORMAT, FORMATBOTTOM), FORMATBOTTOM) |
| : "GLB of @InvalidFormat(null) and @FormatBottom is not @FormatBottom!"; |
| |
| // GLB of @InvalidFormat("Message") and others |
| |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(invalidFormatWithMessage, UNKNOWNFORMAT), |
| invalidFormatWithMessage) |
| : "GLB of @InvalidFormat(\"Message\") and @UnknownFormat is not" |
| + " @InvalidFormat(\"Message\")!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(invalidFormatWithMessage, FORMAT), FORMATBOTTOM) |
| : "GLB of @InvalidFormat(\"Message\") and @Format(null) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(invalidFormatWithMessage, formatUnusedAnno), FORMATBOTTOM) |
| : "GLB of @InvalidFormat(\"Message\") and @Format(UNUSED) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(invalidFormatWithMessage, invalidFormatWithMessage), |
| invalidFormatWithMessage) |
| : "GLB of @InvalidFormat(\"Message\") and @InvalidFormat(\"Message\") is not" |
| + " @InvalidFormat(\"Message\")!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(invalidFormatWithMessage, invalidFormatWithMessage2), |
| invalidFormatWithMessagesAnded) |
| : "GLB of @InvalidFormat(\"Message\") and @InvalidFormat(\"Message2\") is not" |
| + " @InvalidFormat(\"(\"Message\" and \"Message2\")\")!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(invalidFormatWithMessage, FORMATBOTTOM), FORMATBOTTOM) |
| : "GLB of @InvalidFormat(\"Message\") and @FormatBottom is not @FormatBottom!"; |
| |
| // GLB of @FormatBottom and others |
| |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(FORMATBOTTOM, UNKNOWNFORMAT), FORMATBOTTOM) |
| : "GLB of @FormatBottom and @UnknownFormat is not @FormatBottom!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(FORMATBOTTOM, FORMAT), FORMATBOTTOM) |
| : "GLB of @FormatBottom and @Format(null) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(FORMATBOTTOM, formatUnusedAnno), FORMATBOTTOM) |
| : "GLB of @FormatBottom and @Format(UNUSED) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(FORMATBOTTOM, INVALIDFORMAT), FORMATBOTTOM) |
| : "GLB of @FormatBottom and @InvalidFormat(null) is not @FormatBottom!"; |
| assert AnnotationUtils.areSame( |
| qh.greatestLowerBound(FORMATBOTTOM, invalidFormatWithMessage), FORMATBOTTOM) |
| : "GLB of @FormatBottom and @InvalidFormat(\"Message\") is not @FormatBottom!"; |
| assert AnnotationUtils.areSame(qh.greatestLowerBound(FORMATBOTTOM, FORMATBOTTOM), FORMATBOTTOM) |
| : "GLB of @FormatBottom and @FormatBottom is not @FormatBottom!"; |
| |
| // ** LUB tests ** |
| |
| // LUB of UNUSED and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatUnusedAnno), formatUnusedAnno) |
| : "LUB of @Format(UNUSED) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatGeneralAnno), formatGeneralAnno) |
| : "LUB of @Format(UNUSED) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatCharAnno), formatCharAnno) |
| : "LUB of @Format(UNUSED) and @Format(CHAR) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatIntAnno), formatIntAnno) |
| : "LUB of @Format(UNUSED) and @Format(INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatTimeAnno), formatTimeAnno) |
| : "LUB of @Format(UNUSED) and @Format(TIME) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatFloatAnno), formatFloatAnno) |
| : "LUB of @Format(UNUSED) and @Format(FLOAT) is not @Format(FLOAT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatCharAndIntAnno), formatCharAndIntAnno) |
| : "LUB of @Format(UNUSED) and @Format(CHAR_AND_INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatIntAndTimeAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(UNUSED) and @Format(INT_AND_TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(UNUSED) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of GENERAL and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatUnusedAnno), formatGeneralAnno) |
| : "LUB of @Format(GENERAL) and @Format(UNUSED) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatGeneralAnno), formatGeneralAnno) |
| : "LUB of @Format(GENERAL) and @Format(GENERAL) is not @Format(GENERAL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatCharAnno), formatCharAnno) |
| : "LUB of @Format(GENERAL) and @Format(CHAR) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatIntAnno), formatIntAnno) |
| : "LUB of @Format(GENERAL) and @Format(INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatTimeAnno), formatTimeAnno) |
| : "LUB of @Format(GENERAL) and @Format(TIME) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatFloatAnno), formatFloatAnno) |
| : "LUB of @Format(GENERAL) and @Format(FLOAT) is not @Format(FLOAT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatCharAndIntAnno), formatCharAndIntAnno) |
| : "LUB of @Format(GENERAL) and @Format(CHAR_AND_INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatIntAndTimeAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(GENERAL) and @Format(INT_AND_TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(GENERAL) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of CHAR and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatUnusedAnno), formatCharAnno) |
| : "LUB of @Format(CHAR) and @Format(UNUSED) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatGeneralAnno), formatCharAnno) |
| : "LUB of @Format(CHAR) and @Format(GENERAL) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatCharAnno), formatCharAnno) |
| : "LUB of @Format(CHAR) and @Format(CHAR) is not @Format(CHAR)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatIntAnno), formatCharAndIntAnno) |
| : "LUB of @Format(CHAR) and @Format(INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatTimeAnno), formatNullAnno) |
| : "LUB of @Format(CHAR) and @Format(TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatFloatAnno), formatNullAnno) |
| : "LUB of @Format(CHAR) and @Format(FLOAT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatCharAndIntAnno), formatCharAndIntAnno) |
| : "LUB of @Format(CHAR) and @Format(CHAR_AND_INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatIntAndTimeAnno), formatNullAnno) |
| : "LUB of @Format(CHAR) and @Format(INT_AND_TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(CHAR) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of INT and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatUnusedAnno), formatIntAnno) |
| : "LUB of @Format(INT) and @Format(UNUSED) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatGeneralAnno), formatIntAnno) |
| : "LUB of @Format(INT) and @Format(GENERAL) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatCharAnno), formatCharAndIntAnno) |
| : "LUB of @Format(INT) and @Format(CHAR) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(formatIntAnno, formatIntAnno), formatIntAnno) |
| : "LUB of @Format(INT) and @Format(INT) is not @Format(INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatTimeAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(INT) and @Format(TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatFloatAnno), formatNullAnno) |
| : "LUB of @Format(INT) and @Format(FLOAT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatCharAndIntAnno), formatCharAndIntAnno) |
| : "LUB of @Format(INT) and @Format(CHAR_AND_INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatIntAndTimeAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(INT) and @Format(INT_AND_TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(INT) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of TIME and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatUnusedAnno), formatTimeAnno) |
| : "LUB of @Format(TIME) and @Format(UNUSED) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatGeneralAnno), formatTimeAnno) |
| : "LUB of @Format(TIME) and @Format(GENERAL) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatCharAnno), formatNullAnno) |
| : "LUB of @Format(TIME) and @Format(CHAR) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatIntAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(TIME) and @Format(INT) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatTimeAnno), formatTimeAnno) |
| : "LUB of @Format(TIME) and @Format(TIME) is not @Format(TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatFloatAnno), formatNullAnno) |
| : "LUB of @Format(TIME) and @Format(FLOAT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatCharAndIntAnno), formatNullAnno) |
| : "LUB of @Format(TIME) and @Format(CHAR_AND_INT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatIntAndTimeAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(TIME) and @Format(INT_AND_TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTimeAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(TIME) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of FLOAT and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatUnusedAnno), formatFloatAnno) |
| : "LUB of @Format(FLOAT) and @Format(UNUSED) is not @Format(FLOAT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatGeneralAnno), formatFloatAnno) |
| : "LUB of @Format(FLOAT) and @Format(GENERAL) is not @Format(FLOAT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatCharAnno), formatNullAnno) |
| : "LUB of @Format(FLOAT) and @Format(CHAR) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatIntAnno), formatNullAnno) |
| : "LUB of @Format(FLOAT) and @Format(INT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatTimeAnno), formatNullAnno) |
| : "LUB of @Format(FLOAT) and @Format(TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatFloatAnno), formatFloatAnno) |
| : "LUB of @Format(FLOAT) and @Format(FLOAT) is not @Format(FLOAT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatCharAndIntAnno), formatNullAnno) |
| : "LUB of @Format(FLOAT) and @Format(CHAR_AND_INT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatIntAndTimeAnno), formatNullAnno) |
| : "LUB of @Format(FLOAT) and @Format(INT_AND_TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatFloatAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(FLOAT) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of CHAR_AND_INT and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatUnusedAnno), formatCharAndIntAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(UNUSED) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatGeneralAnno), formatCharAndIntAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(GENERAL) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatCharAnno), formatCharAndIntAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(CHAR) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatIntAnno), formatCharAndIntAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatTimeAnno), formatNullAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatFloatAnno), formatNullAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(FLOAT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatCharAndIntAnno), formatCharAndIntAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(CHAR_AND_INT) is not @Format(CHAR_AND_INT)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatIntAndTimeAnno), formatNullAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(INT_AND_TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatCharAndIntAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(CHAR_AND_INT) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of INT_AND_TIME and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatUnusedAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(UNUSED) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatGeneralAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(GENERAL) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatCharAnno), formatNullAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(CHAR) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatIntAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(INT) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatTimeAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatFloatAnno), formatNullAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(FLOAT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatCharAndIntAnno), formatNullAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(CHAR_AND_INT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatIntAndTimeAnno), formatIntAndTimeAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(INT_AND_TIME) is not @Format(INT_AND_TIME)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatIntAndTimeAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(INT_AND_TIME) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // LUB of NULL and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatUnusedAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(UNUSED) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatGeneralAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(GENERAL) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatCharAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(CHAR) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatIntAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(INT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatTimeAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatFloatAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(FLOAT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatCharAndIntAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(CHAR_AND_INT) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatIntAndTimeAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(INT_AND_TIME) is not @Format(NULL)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatNullAnno, formatNullAnno), formatNullAnno) |
| : "LUB of @Format(NULL) and @Format(NULL) is not @Format(NULL)!"; |
| |
| // Now test with two ConversionCategory at a time: |
| |
| cc2[0] = ConversionCategory.CHAR_AND_INT; |
| cc2[1] = ConversionCategory.NULL; |
| AnnotationMirror formatTwoConvCat4 = treeUtil.categoriesToFormatAnnotation(cc2); |
| cc2[0] = ConversionCategory.NULL; |
| cc2[1] = ConversionCategory.CHAR; |
| AnnotationMirror formatTwoConvCat5 = treeUtil.categoriesToFormatAnnotation(cc2); |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTwoConvCat1, formatTwoConvCat2), formatTwoConvCat4) |
| : "LUB of @Format([CHAR_AND_INT,FLOAT]) and @Format([INT,CHAR]) is not" |
| + " @Format([CHAR_AND_INT,NULL])!"; |
| |
| // Test that the LUB of two ConversionCategory arrays of different sizes is an array of the |
| // largest size of the two: |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatGeneralAnno, formatTwoConvCat1), formatTwoConvCat1) |
| : "LUB of @I18nFormat(GENERAL) and @I18nFormat([CHAR_AND_INT,FLOAT]) is not" |
| + " @I18nFormat([CHAR_AND_INT,FLOAT])!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatTwoConvCat2, formatNullAnno), formatTwoConvCat5) |
| : "LUB of @I18nFormat([INT,CHAR]) and @I18nFormat(NULL) is not @I18nFormat([NULL,CHAR])!"; |
| |
| // LUB of @UnknownFormat and others |
| |
| assert AnnotationUtils.areSame(qh.leastUpperBound(UNKNOWNFORMAT, UNKNOWNFORMAT), UNKNOWNFORMAT) |
| : "LUB of @UnknownFormat and @UnknownFormat is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(UNKNOWNFORMAT, FORMAT), UNKNOWNFORMAT) |
| : "LUB of @UnknownFormat and @Format(null) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(UNKNOWNFORMAT, formatUnusedAnno), UNKNOWNFORMAT) |
| : "LUB of @UnknownFormat and @Format(UNUSED) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(UNKNOWNFORMAT, INVALIDFORMAT), UNKNOWNFORMAT) |
| : "LUB of @UnknownFormat and @InvalidFormat(null) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(UNKNOWNFORMAT, invalidFormatWithMessage), UNKNOWNFORMAT) |
| : "LUB of @UnknownFormat and @InvalidFormat(\"Message\") is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(UNKNOWNFORMAT, FORMATBOTTOM), UNKNOWNFORMAT) |
| : "LUB of @UnknownFormat and @FormatBottom is not @UnknownFormat!"; |
| |
| // LUB of @Format(null) and others |
| |
| assert AnnotationUtils.areSame(qh.leastUpperBound(FORMAT, UNKNOWNFORMAT), UNKNOWNFORMAT) |
| : "LUB of @Format(null) and @UnknownFormat is not @UnknownFormat!"; |
| // Computing the LUB of @Format(null) and @Format(null) should never occur in practice. |
| // Skipping this case as it causes an expected crash. |
| // Computing the LUB of @Format(null) and @Format with a value should never occur in |
| // practice. Skipping this case as it causes an expected crash. |
| assert AnnotationUtils.areSame(qh.leastUpperBound(FORMAT, INVALIDFORMAT), UNKNOWNFORMAT) |
| : "LUB of @Format(null) and @InvalidFormat(null) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(FORMAT, invalidFormatWithMessage), UNKNOWNFORMAT) |
| : "LUB of @Format(null) and @InvalidFormat(\"Message\") is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(FORMAT, FORMATBOTTOM), FORMAT) |
| : "LUB of @Format(null) and @FormatBottom is not @Format(null)!"; |
| |
| // LUB of @Format(UNUSED) and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, UNKNOWNFORMAT), UNKNOWNFORMAT) |
| : "LUB of @Format(UNUSED) and @UnknownFormat is not @UnknownFormat!"; |
| // Computing the LUB of @Format with a value and @Format(null) should never occur in |
| // practice. Skipping this case as it causes an expected crash. |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, formatUnusedAnno), formatUnusedAnno) |
| : "LUB of @Format(UNUSED) and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, INVALIDFORMAT), UNKNOWNFORMAT) |
| : "LUB of @Format(UNUSED) and @InvalidFormat(null) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, invalidFormatWithMessage), UNKNOWNFORMAT) |
| : "LUB of @Format(UNUSED) and @InvalidFormat(\"Message\") is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(formatUnusedAnno, FORMATBOTTOM), formatUnusedAnno) |
| : "LUB of @Format(UNUSED) and @FormatBottom is not @Format(UNUSED)!"; |
| |
| // LUB of @InvalidFormat(null) and others |
| |
| assert AnnotationUtils.areSame(qh.leastUpperBound(INVALIDFORMAT, UNKNOWNFORMAT), UNKNOWNFORMAT) |
| : "LUB of @InvalidFormat(null) and @UnknownFormat is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(INVALIDFORMAT, FORMAT), UNKNOWNFORMAT) |
| : "LUB of @InvalidFormat(null) and @Format(null) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(INVALIDFORMAT, formatUnusedAnno), UNKNOWNFORMAT) |
| : "LUB of @InvalidFormat(null) and @Format(UNUSED) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(INVALIDFORMAT, FORMATBOTTOM), INVALIDFORMAT) |
| : "LUB of @InvalidFormat(null) and @FormatBottom is not @InvalidFormat(null)!"; |
| |
| // LUB of @InvalidFormat("Message") and others |
| |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(invalidFormatWithMessage, UNKNOWNFORMAT), UNKNOWNFORMAT) |
| : "LUB of @InvalidFormat(\"Message\") and @UnknownFormat is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(invalidFormatWithMessage, FORMAT), UNKNOWNFORMAT) |
| : "LUB of @InvalidFormat(\"Message\") and @Format(null) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(invalidFormatWithMessage, formatUnusedAnno), UNKNOWNFORMAT) |
| : "LUB of @InvalidFormat(\"Message\") and @Format(UNUSED) is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(invalidFormatWithMessage, invalidFormatWithMessage), |
| invalidFormatWithMessage) |
| : "LUB of @InvalidFormat(\"Message\") and @InvalidFormat(\"Message\") is not" |
| + " @InvalidFormat(\"Message\")!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(invalidFormatWithMessage, invalidFormatWithMessage2), |
| invalidFormatWithMessagesOred) |
| : "LUB of @InvalidFormat(\"Message\") and @InvalidFormat(\"Message2\") is not" |
| + " @InvalidFormat(\"(\"Message\" or \"Message2\")\")!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(invalidFormatWithMessage, FORMATBOTTOM), invalidFormatWithMessage) |
| : "LUB of @InvalidFormat(\"Message\") and @FormatBottom is not" |
| + " @InvalidFormat(\"Message\")!"; |
| |
| // LUB of @FormatBottom and others |
| |
| assert AnnotationUtils.areSame(qh.leastUpperBound(FORMATBOTTOM, UNKNOWNFORMAT), UNKNOWNFORMAT) |
| : "LUB of @FormatBottom and @UnknownFormat is not @UnknownFormat!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(FORMATBOTTOM, FORMAT), FORMAT) |
| : "LUB of @FormatBottom and @Format(null) is not @Format(null)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(FORMATBOTTOM, formatUnusedAnno), formatUnusedAnno) |
| : "LUB of @FormatBottom and @Format(UNUSED) is not @Format(UNUSED)!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(FORMATBOTTOM, INVALIDFORMAT), INVALIDFORMAT) |
| : "LUB of @FormatBottom and @InvalidFormat(null) is not @InvalidFormat(null)!"; |
| assert AnnotationUtils.areSame( |
| qh.leastUpperBound(FORMATBOTTOM, invalidFormatWithMessage), invalidFormatWithMessage) |
| : "LUB of @FormatBottom and @InvalidFormat(\"Message\") is not" |
| + " @InvalidFormat(\"Message\")!"; |
| assert AnnotationUtils.areSame(qh.leastUpperBound(FORMATBOTTOM, FORMATBOTTOM), FORMATBOTTOM) |
| : "LUB of @FormatBottom and @FormatBottom is not @FormatBottom!"; |
| } |
| } |
