/
Antonn10
/
Java
GigaCode
beta
ОбзорЦентр заботыВойти

Java

Форк
0
Ветки: 29Коммиты: 6616Теги: 109
Java
/guava-testlib
/test
/com
/google
/common
/collect
/testing
/features
/
FeatureUtilTest.java 
312 строк · 11.5 Кб
1
/*
2
 * Copyright (C) 2008 The Guava Authors
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 * http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16


17
package com.google.common.collect.testing.features;
18


19
import static com.google.common.collect.Sets.newHashSet;
20
import static com.google.common.collect.testing.features.FeatureEnumTest.assertGoodFeatureEnum;
21
import static com.google.common.collect.testing.features.FeatureUtil.addImpliedFeatures;
22
import static com.google.common.collect.testing.features.FeatureUtil.buildDeclaredTesterRequirements;
23
import static com.google.common.collect.testing.features.FeatureUtil.buildTesterRequirements;
24
import static com.google.common.collect.testing.features.FeatureUtil.getTesterAnnotations;
25
import static com.google.common.collect.testing.features.FeatureUtil.impliedFeatures;
26
import static com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.BAR;
27
import static com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.FOO;
28
import static com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.IMPLIES_BAR;
29
import static com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.IMPLIES_FOO;
30
import static com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.IMPLIES_IMPLIES_FOO;
31
import static com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR;
32
import static com.google.common.truth.Truth.assertThat;
33
import static java.lang.annotation.RetentionPolicy.RUNTIME;
34
import static org.junit.Assert.assertThrows;
35


36
import com.google.common.collect.ImmutableSet;
37
import com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.NotTesterAnnotation;
38
import com.google.common.collect.testing.features.FeatureUtilTest.ExampleFeature.Require;
39
import java.lang.annotation.Inherited;
40
import java.lang.annotation.Retention;
41
import java.lang.reflect.Method;
42
import java.util.Set;
43
import junit.framework.TestCase;
44


45
/**
46
 * @author George van den Driessche
47
 */
48
public class FeatureUtilTest extends TestCase {
49
  enum ExampleFeature implements Feature<Object> {
50
    FOO,
51
    IMPLIES_FOO,
52
    IMPLIES_IMPLIES_FOO,
53
    BAR,
54
    IMPLIES_BAR,
55
    IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR;
56


57
    @Override
58
    public ImmutableSet<Feature<? super Object>> getImpliedFeatures() {
59
      switch (this) {
60
        case IMPLIES_FOO:
61
          return ImmutableSet.of(FOO);
62
        case IMPLIES_IMPLIES_FOO:
63
          return ImmutableSet.of(IMPLIES_FOO);
64
        case IMPLIES_BAR:
65
          return ImmutableSet.of(BAR);
66
        case IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR:
67
          return ImmutableSet.of(IMPLIES_FOO, IMPLIES_BAR);
68
        default:
69
          return ImmutableSet.of();
70
      }
71
    }
72


73
    @Retention(RUNTIME)
74
    @Inherited
75
    @TesterAnnotation
76
    @interface Require {
77
      ExampleFeature[] value() default {};
78


79
      ExampleFeature[] absent() default {};
80
    }
81


82
    @Retention(RUNTIME)
83
    @Inherited
84
    @interface NotTesterAnnotation {
85
      ExampleFeature[] value() default {};
86


87
      ExampleFeature[] absent() default {};
88
    }
89
  }
90


91
  public void testTestFeatureEnums() {
92
    // Haha! Let's test our own test rig!
93
    assertGoodFeatureEnum(ExampleFeature.class);
94
  }
95


96
  public void testAddImpliedFeatures_returnsSameSetInstance() {
97
    Set<Feature<?>> features = newHashSet(FOO);
98
    assertThat(addImpliedFeatures(features)).isSameInstanceAs(features);
99
  }
100


101
  public void testAddImpliedFeatures_addsImpliedFeatures() {
102
    assertThat(addImpliedFeatures(newHashSet(FOO))).containsExactly(FOO);
103


104
    assertThat(addImpliedFeatures(newHashSet(IMPLIES_IMPLIES_FOO)))
105
        .containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_FOO, FOO);
106


107
    assertThat(addImpliedFeatures(newHashSet(IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR)))
108
        .containsExactly(IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR, IMPLIES_FOO, FOO, IMPLIES_BAR, BAR);
109
  }
110


111
  public void testImpliedFeatures_returnsNewSetInstance() {
112
    Set<Feature<?>> features = newHashSet(IMPLIES_FOO);
113
    assertThat(impliedFeatures(features)).isNotSameInstanceAs(features);
114
  }
115


116
  public void testImpliedFeatures_returnsImpliedFeatures() {
117
    assertThat(impliedFeatures(newHashSet(FOO))).isEmpty();
118


119
    assertThat(impliedFeatures(newHashSet(IMPLIES_IMPLIES_FOO))).containsExactly(IMPLIES_FOO, FOO);
120


121
    assertThat(impliedFeatures(newHashSet(IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR)))
122
        .containsExactly(IMPLIES_FOO, FOO, IMPLIES_BAR, BAR);
123
  }
124


125
  public void testBuildTesterRequirements_class_notAnnotated() throws Exception {
126
    class Tester {}
127


128
    TesterRequirements requirements = buildTesterRequirements(Tester.class);
129


130
    assertThat(requirements.getPresentFeatures()).isEmpty();
131
    assertThat(requirements.getAbsentFeatures()).isEmpty();
132
  }
133


134
  public void testBuildTesterRequirements_class_empty() throws Exception {
135
    @Require
136
    class Tester {}
137


138
    TesterRequirements requirements = buildTesterRequirements(Tester.class);
139


140
    assertThat(requirements.getPresentFeatures()).isEmpty();
141
    assertThat(requirements.getAbsentFeatures()).isEmpty();
142
  }
143


144
  public void testBuildTesterRequirements_class_present() throws Exception {
145
    @Require({IMPLIES_IMPLIES_FOO, IMPLIES_BAR})
146
    class Tester {}
147


148
    TesterRequirements requirements = buildTesterRequirements(Tester.class);
149


150
    assertThat(requirements.getPresentFeatures())
151
        .containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_FOO, FOO, IMPLIES_BAR, BAR);
152
    assertThat(requirements.getAbsentFeatures()).isEmpty();
153
  }
154


155
  public void testBuildTesterRequirements_class_absent() throws Exception {
156
    @Require(absent = {IMPLIES_IMPLIES_FOO, IMPLIES_BAR})
157
    class Tester {}
158


159
    TesterRequirements requirements = buildTesterRequirements(Tester.class);
160


161
    assertThat(requirements.getPresentFeatures()).isEmpty();
162
    assertThat(requirements.getAbsentFeatures()).containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_BAR);
163
  }
164


165
  public void testBuildTesterRequirements_class_present_and_absent() throws Exception {
166
    @Require(value = IMPLIES_FOO, absent = IMPLIES_IMPLIES_FOO)
167
    class Tester {}
168


169
    TesterRequirements requirements = buildTesterRequirements(Tester.class);
170


171
    assertThat(requirements.getPresentFeatures()).containsExactly(IMPLIES_FOO, FOO);
172
    assertThat(requirements.getAbsentFeatures()).containsExactly(IMPLIES_IMPLIES_FOO);
173
  }
174


175
  public void testBuildTesterRequirements_class_present_method_present() throws Exception {
176
    @Require(IMPLIES_BAR)
177
    class Tester {
178
      @Require(IMPLIES_IMPLIES_FOO)
179
      public void test() {}
180
    }
181


182
    TesterRequirements requirements = buildTesterRequirements(Tester.class.getMethod("test"));
183


184
    assertThat(requirements.getPresentFeatures())
185
        .containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_FOO, FOO, IMPLIES_BAR, BAR);
186
    assertThat(requirements.getAbsentFeatures()).isEmpty();
187
  }
188


189
  public void testBuildTesterRequirements_class_absent_method_absent() throws Exception {
190
    @Require(absent = IMPLIES_BAR)
191
    class Tester {
192
      @Require(absent = IMPLIES_IMPLIES_FOO)
193
      public void test() {}
194
    }
195


196
    TesterRequirements requirements = buildTesterRequirements(Tester.class.getMethod("test"));
197


198
    assertThat(requirements.getPresentFeatures()).isEmpty();
199
    assertThat(requirements.getAbsentFeatures()).containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_BAR);
200
  }
201


202
  public void testBuildTesterRequirements_class_present_method_absent() throws Exception {
203
    @Require(IMPLIES_IMPLIES_FOO)
204
    class Tester {
205
      @Require(absent = IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR)
206
      public void test() {}
207
    }
208


209
    TesterRequirements requirements = buildTesterRequirements(Tester.class.getMethod("test"));
210


211
    assertThat(requirements.getPresentFeatures())
212
        .containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_FOO, FOO);
213
    assertThat(requirements.getAbsentFeatures())
214
        .containsExactly(IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR);
215
  }
216


217
  public void testBuildTesterRequirements_class_absent_method_present() throws Exception {
218
    @Require(absent = IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR)
219
    class Tester {
220
      @Require(IMPLIES_IMPLIES_FOO)
221
      public void test() {}
222
    }
223


224
    TesterRequirements requirements = buildTesterRequirements(Tester.class.getMethod("test"));
225


226
    assertThat(requirements.getPresentFeatures())
227
        .containsExactly(IMPLIES_IMPLIES_FOO, IMPLIES_FOO, FOO);
228
    assertThat(requirements.getAbsentFeatures())
229
        .containsExactly(IMPLIES_IMPLIES_FOO_AND_IMPLIES_BAR);
230
  }
231


232
  public void testBuildTesterRequirements_classClassConflict() {
233
    @Require(value = FOO, absent = FOO)
234
    class Tester {}
235


236
    ConflictingRequirementsException e =
237
        assertThrows(
238
            ConflictingRequirementsException.class, () -> buildTesterRequirements(Tester.class));
239
    assertThat(e.getConflicts()).containsExactly(FOO);
240
    assertThat(e.getSource()).isEqualTo(Tester.class.getAnnotation(Require.class));
241
  }
242


243
  public void testBuildTesterRequirements_classClassConflict_inherited() {
244
    @Require(FOO)
245
    abstract class BaseTester {}
246
    @Require(absent = FOO)
247
    class Tester extends BaseTester {}
248


249
    ConflictingRequirementsException e =
250
        assertThrows(
251
            ConflictingRequirementsException.class, () -> buildTesterRequirements(Tester.class));
252
    assertThat(e.getConflicts()).containsExactly(FOO);
253
    assertThat(e.getSource()).isEqualTo(Tester.class);
254
  }
255


256
  public void testBuildTesterRequirements_classClassConflict_implied() {
257
    @Require(value = IMPLIES_FOO, absent = FOO)
258
    class Tester {}
259


260
    ConflictingRequirementsException e =
261
        assertThrows(
262
            ConflictingRequirementsException.class, () -> buildTesterRequirements(Tester.class));
263
    assertThat(e.getConflicts()).containsExactly(FOO);
264
    assertThat(e.getSource()).isEqualTo(Tester.class.getAnnotation(Require.class));
265
  }
266


267
  public void testBuildTesterRequirements_methodClassConflict() throws Exception {
268
    @Require(IMPLIES_FOO)
269
    class Tester {
270
      @Require(absent = FOO)
271
      public void test() {}
272
    }
273


274
    Method method = Tester.class.getMethod("test");
275
    ConflictingRequirementsException e =
276
        assertThrows(ConflictingRequirementsException.class, () -> buildTesterRequirements(method));
277
    assertThat(e.getConflicts()).containsExactly(FOO);
278
    assertThat(e.getSource()).isEqualTo(method);
279
  }
280


281
  public void testBuildDeclaredTesterRequirements() throws Exception {
282
    @Require(IMPLIES_FOO)
283
    abstract class BaseTester {}
284
    @Require(IMPLIES_BAR)
285
    class Tester extends BaseTester {}
286


287
    TesterRequirements requirements = buildDeclaredTesterRequirements(Tester.class);
288


289
    assertThat(requirements.getPresentFeatures()).containsExactly(IMPLIES_BAR, BAR);
290
    assertThat(requirements.getAbsentFeatures()).isEmpty();
291
  }
292


293
  public void testGetTesterAnnotations_class() {
294
    @Require
295
    @NotTesterAnnotation
296
    class Tester {}
297


298
    assertThat(getTesterAnnotations(Tester.class))
299
        .containsExactly(Tester.class.getAnnotation(Require.class));
300
  }
301


302
  public void testGetTesterAnnotations_method() throws Exception {
303
    class Tester {
304
      @Require
305
      @NotTesterAnnotation
306
      public void test() {}
307
    }
308
    Method method = Tester.class.getMethod("test");
309


310
    assertThat(getTesterAnnotations(method)).containsExactly(method.getAnnotation(Require.class));
311
  }
312
}
313

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.