Clover icon

core 1.0-SNAPSHOT

  1. Project Clover database Wed Nov 12 2025 05:07:35 UTC
  2. Package guru.mikelue.foxglove.annotation

File ReflectGenDataObjectFactoryTest.java

 

Code metrics

4
56
21
6
263
214
23
0.41
2.67
3.5
1.1

Classes

Class Line # Actions
ReflectGenDataObjectFactoryTest 27 51 0% 18 0
1.0100%
ReflectGenDataObjectFactoryTest.FakeDataGeneratorProvider 85 1 0% 1 2
0.00%
ReflectGenDataObjectFactoryTest.TestCase 203 0 - 0 0
-1.0 -
ReflectGenDataObjectFactoryTest.FakeTableFacetsProvider_1 186 1 0% 1 2
0.00%
ReflectGenDataObjectFactoryTest.FakeTableFacetsProvider_2 193 1 0% 1 2
0.00%
FakeDataGenerator 251 2 0% 2 4
0.00%
 

Contributing tests

This file is covered by 6 tests. .

Source view

1    package guru.mikelue.foxglove.annotation;
2   
3    import java.util.List;
4    import java.util.Optional;
5    import java.util.function.BiConsumer;
6    import java.util.stream.Stream;
7   
8    import org.junit.jupiter.api.AfterEach;
9    import org.junit.jupiter.api.BeforeEach;
10    import org.junit.jupiter.params.ParameterizedTest;
11    import org.junit.jupiter.params.provider.Arguments;
12    import org.junit.jupiter.params.provider.MethodSource;
13   
14    import guru.mikelue.misc.testlib.AbstractTestBase;
15   
16    import guru.mikelue.foxglove.DataGenerator;
17    import guru.mikelue.foxglove.TableFacet;
18    import guru.mikelue.foxglove.functional.DataGeneratorProvider;
19    import guru.mikelue.foxglove.functional.TableFacetProvider;
20    import guru.mikelue.foxglove.functional.TableFacetsProvider;
21    import guru.mikelue.foxglove.setting.DataSettingInfo;
22    import mockit.Expectations;
23    import mockit.Mocked;
24   
25    import static java.util.Collections.emptyList;
26   
 
27    public class ReflectGenDataObjectFactoryTest extends AbstractTestBase {
28    @Mocked
29    private GenData mockGenData;
30   
31    @Mocked
32    private DataGenContext<TableFacet> mockDataGenContext;
33   
34    private static DataGenerator<TableFacet> fakeDataGenerator = new FakeDataGenerator();
35   
 
36  6 toggle public ReflectGenDataObjectFactoryTest() {}
37   
 
38  6 toggle @BeforeEach
39    void setup() {}
40   
 
41  6 toggle @AfterEach
42    void tearDown() {}
43   
 
44  3 toggle @ParameterizedTest
45    @MethodSource
46    void getDataGenerator(
47    String generatorName, Class<? extends DataGeneratorProvider<TableFacet>> providerClass,
48    BiConsumer<DataGenContext<TableFacet>, Object> verifyFunction
49    ) throws Exception {
50  3 var currentObject = this;
51   
 
52  3 toggle new Expectations() {{
53  3 mockGenData.generatorName();
54  3 result = generatorName;
55   
56  3 mockGenData.generator();
57  3 result = providerClass;
58    }};
59   
60  3 verifyFunction.accept(mockDataGenContext, currentObject);
61   
62  3 if (!generatorName.isEmpty()) {
 
63  1 toggle new Expectations() {{
64  1 mockDataGenContext.getNamedDataGenerator(
65    generatorName, currentObject
66    );
67  1 result = fakeDataGenerator;
68  1 times = 1;
69    }};
70    }
71   
72  3 if (!GenData.FallbackDataGeneratorProvider.class.equals(providerClass)) {
 
73  1 toggle new Expectations() {{
74  1 mockDataGenContext.getTypedDataGenerator(
75    providerClass, currentObject
76    );
77  1 result = fakeDataGenerator;
78  1 times = 1;
79    }};
80    }
81   
82  3 newTestedFactory().getDataGenerator();
83    }
84   
 
85    class FakeDataGeneratorProvider implements DataGeneratorProvider<TableFacet> {
 
86  0 toggle @Override
87    public DataGenerator<TableFacet> get()
88    {
89  0 return fakeDataGenerator;
90    }
91    }
92   
 
93  1 toggle static Stream<Arguments> getDataGenerator()
94    {
95    record TestCase(
96    String generatorName,
97    Class<? extends DataGeneratorProvider<TableFacet>> providerClass,
98    BiConsumer<DataGenContext<TableFacet>, Object> verifyFunction
99    ) {}
100   
101  1 return Stream.<TestCase>of(
102    // Default
103    new TestCase(
104    "", GenData.FallbackDataGeneratorProvider.class,
105    (context, obj) -> {
 
106  1 toggle new Expectations() {{
107  1 context.getDefaultDataGenerator(obj);
108  1 result = Optional.of(fakeDataGenerator);
109  1 times = 1;
110    }};
111    }
112    ),
113    // Uses class of provider
114    new TestCase(
115    "", FakeDataGeneratorProvider.class,
116    (context, obj) -> {}
117    ),
118    // Uses named data generator
119    new TestCase(
120    "fakeName", GenData.FallbackDataGeneratorProvider.class,
121    (context, obj) -> {}
122    )
123    )
124    .map(testCase -> Arguments.of(
125    testCase.generatorName,
126    testCase.providerClass,
127    testCase.verifyFunction
128    ));
129    }
130   
131    /**
132    * Tests the getting of {@link TableFacet}s.
133    */
 
134  3 toggle @ParameterizedTest
135    @MethodSource
136    void getTableFacets(
137    Class<? extends TableFacetsProvider<TableFacet>>[] providers,
138    String[] names,
139    BiConsumer<DataGenContext<TableFacet>, Object> verifyFunction
140    ) throws Exception {
141  3 var currentObject = this;
142   
143    /*
144    * Mocks the GenData info
145    */
 
146  3 toggle new Expectations() {{
147  3 mockGenData.generatorName();
148  3 result = "";
149   
150  3 mockGenData.value();
151  3 result = providers;
152   
153  3 mockGenData.facets();
154  3 result = providers;
155   
156  3 mockGenData.facetsNames();
157  3 result = names;
158    }};
159   
160  3 for (var providerClass: providers) {
 
161  2 toggle new Expectations() {{
162  2 mockDataGenContext.getTypedTableFacets(
163    providerClass, currentObject
164    );
165  2 result = emptyList();
166  2 times = 2;
167    }};
168    }
169   
170  3 for (var name: names) {
 
171  2 toggle new Expectations() {{
172  2 mockDataGenContext.getNamedTableFacets(
173    name, currentObject
174    );
175  2 result = emptyList();
176  2 times = 1;
177    }};
178    }
179    // :~)
180   
181  3 verifyFunction.accept(mockDataGenContext, currentObject);
182   
183  3 newTestedFactory().getTableFacets();
184    }
185   
 
186    class FakeTableFacetsProvider_1 implements TableFacetProvider<TableFacet> {
 
187  0 toggle @Override
188    public TableFacet getOne()
189    {
190  0 return null;
191    }
192    }
 
193    class FakeTableFacetsProvider_2 implements TableFacetProvider<TableFacet> {
 
194  0 toggle @Override
195    public TableFacet getOne()
196    {
197  0 return null;
198    }
199    }
200   
 
201  1 toggle static Stream<Arguments> getTableFacets()
202    {
 
203    record TestCase(
204    Class<?>[] providers,
205    String[] names,
206    BiConsumer<DataGenContext<TableFacet>, Object> verifyFunction
207    ) {}
208   
209  1 return Stream.<TestCase>of(
210    // By default resolving
211    new TestCase(
212    new Class<?>[0], new String[0],
213    (context, obj) -> {
 
214  1 toggle new Expectations() {{
215  1 context.getDefaultTableFacets(obj);
216  1 result = Optional.of(emptyList());
217  1 times = 1;
218    }};
219    }
220    ),
221    // By class of providers
222    new TestCase(
223    new Class<?>[] { FakeTableFacetsProvider_1.class, FakeTableFacetsProvider_2.class },
224    new String[0],
225    (context, obj) -> {}
226    ),
227    // By names of facets
228    new TestCase(
229    new Class<?>[0],
230    new String[] { "fakeName1", "fakeName2" },
231    (context, obj) -> {}
232    )
233    )
234    .map(testCase -> Arguments.of(
235    testCase.providers,
236    testCase.names,
237    testCase.verifyFunction
238    ));
239    }
240   
 
241  6 toggle private ReflectGenDataObjectFactory newTestedFactory()
242    {
243  6 return new ReflectGenDataObjectFactory(
244    this,
245    mockGenData, mockDataGenContext,
246    "Test-Main"
247    );
248    }
249    }
250   
 
251    class FakeDataGenerator implements DataGenerator<TableFacet> {
 
252  0 toggle @Override
253    public DataGenerator<TableFacet> withSetting(DataSettingInfo setting)
254    {
255  0 throw new UnsupportedOperationException("Unimplemented method 'withSetting'");
256    }
257   
 
258  0 toggle @Override
259    public int generate(List<TableFacet> tables)
260    {
261  0 throw new UnsupportedOperationException("Unimplemented method 'generate'");
262    }
263    }
  • Report generated by OpenClover v 4.5.2 on Wed Nov 12 2025 05:07:53 UTC using coverage data from Wed Nov 12 2025 05:07:50 UTC.
  • OpenClover is free and open-source software.