CoCalc -- ConfigurationTest.java

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/test/jdk/java/lang/module/ConfigurationTest.java
⁴¹¹⁴⁹ views
1
/*
2
 * Copyright (c) 2014, 2020, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 */
23

24
/**
25
 * @test
26
 * @library /test/lib
27
 * @modules java.base/jdk.internal.access
28
 *          java.base/jdk.internal.module
29
 * @build ConfigurationTest
30
 *        jdk.test.lib.util.ModuleUtils
31
 * @run testng ConfigurationTest
32
 * @summary Basic tests for java.lang.module.Configuration
33
 */
34

35
import java.io.IOException;
36
import java.io.OutputStream;
37
import java.lang.module.Configuration;
38
import java.lang.module.FindException;
39
import java.lang.module.ModuleDescriptor;
40
import java.lang.module.ModuleDescriptor.Requires;
41
import java.lang.module.ModuleFinder;
42
import java.lang.module.ResolutionException;
43
import java.lang.module.ResolvedModule;
44
import java.nio.file.Files;
45
import java.nio.file.Path;
46
import java.nio.file.Paths;
47
import java.util.List;
48
import java.util.Set;
49

50
import jdk.test.lib.util.ModuleUtils;
51

52
import jdk.internal.access.SharedSecrets;
53
import jdk.internal.module.ModuleInfoWriter;
54
import jdk.internal.module.ModuleTarget;
55
import org.testng.annotations.DataProvider;
56
import org.testng.annotations.Test;
57
import static org.testng.Assert.*;
58

59
@Test
60
public class ConfigurationTest {
61

62
    /**
63
     * Creates a "non-strict" builder for building a module. This allows the
64
     * test the create ModuleDescriptor objects that do not require java.base.
65
     */
66
    private static ModuleDescriptor.Builder newBuilder(String mn) {
67
        return SharedSecrets.getJavaLangModuleAccess()
68
                .newModuleBuilder(mn, false, Set.of());
69
    }
70

71
    /**
72
     * Basic test of resolver
73
     *     m1 requires m2, m2 requires m3
74
     */
75
    public void testBasic() {
76
        ModuleDescriptor descriptor1 = newBuilder("m1")
77
                .requires("m2")
78
                .build();
79

80
        ModuleDescriptor descriptor2 = newBuilder("m2")
81
                .requires("m3")
82
                .build();
83

84
        ModuleDescriptor descriptor3 = newBuilder("m3")
85
                .build();
86

87
        ModuleFinder finder
88
            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
89

90
        Configuration cf = resolve(finder, "m1");
91

92
        assertTrue(cf.modules().size() == 3);
93

94
        assertTrue(cf.findModule("m1").isPresent());
95
        assertTrue(cf.findModule("m2").isPresent());
96
        assertTrue(cf.findModule("m3").isPresent());
97

98
        assertTrue(cf.parents().size() == 1);
99
        assertTrue(cf.parents().get(0) == Configuration.empty());
100

101
        ResolvedModule m1 = cf.findModule("m1").get();
102
        ResolvedModule m2 = cf.findModule("m2").get();
103
        ResolvedModule m3 = cf.findModule("m3").get();
104

105
        // m1 reads m2
106
        assertTrue(m1.reads().size() == 1);
107
        assertTrue(m1.reads().contains(m2));
108

109
        // m2 reads m3
110
        assertTrue(m2.reads().size() == 1);
111
        assertTrue(m2.reads().contains(m3));
112

113
        // m3 reads nothing
114
        assertTrue(m3.reads().size() == 0);
115

116
        // toString
117
        assertTrue(cf.toString().contains("m1"));
118
        assertTrue(cf.toString().contains("m2"));
119
        assertTrue(cf.toString().contains("m3"));
120
    }
121

122

123
    /**
124
     * Basic test of "requires transitive":
125
     *     m1 requires m2, m2 requires transitive m3
126
     */
127
    public void testRequiresTransitive1() {
128
        // m1 requires m2, m2 requires transitive m3
129
        ModuleDescriptor descriptor1 = newBuilder("m1")
130
                .requires("m2")
131
                .build();
132

133
        ModuleDescriptor descriptor2 = newBuilder("m2")
134
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m3")
135
                .build();
136

137
        ModuleDescriptor descriptor3 = newBuilder("m3")
138
                .build();
139

140
        ModuleFinder finder
141
            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
142

143
        Configuration cf = resolve(finder, "m1");
144

145
        assertTrue(cf.modules().size() == 3);
146

147
        assertTrue(cf.findModule("m1").isPresent());
148
        assertTrue(cf.findModule("m2").isPresent());
149
        assertTrue(cf.findModule("m3").isPresent());
150

151
        assertTrue(cf.parents().size() == 1);
152
        assertTrue(cf.parents().get(0) == Configuration.empty());
153

154
        ResolvedModule m1 = cf.findModule("m1").get();
155
        ResolvedModule m2 = cf.findModule("m2").get();
156
        ResolvedModule m3 = cf.findModule("m3").get();
157

158
        // m1 reads m2 and m3
159
        assertTrue(m1.reads().size() == 2);
160
        assertTrue(m1.reads().contains(m2));
161
        assertTrue(m1.reads().contains(m3));
162

163
        // m2 reads m3
164
        assertTrue(m2.reads().size() == 1);
165
        assertTrue(m2.reads().contains(m3));
166

167
        // m3 reads nothing
168
        assertTrue(m3.reads().size() == 0);
169
    }
170

171

172
    /**
173
     * Basic test of "requires transitive" with configurations.
174
     *
175
     * The test consists of three configurations:
176
     * - Configuration cf1: m1, m2 requires transitive m1
177
     * - Configuration cf2: m3 requires m2
178
     */
179
    public void testRequiresTransitive2() {
180

181
        // cf1: m1 and m2, m2 requires transitive m1
182

183
        ModuleDescriptor descriptor1 = newBuilder("m1")
184
                .build();
185

186
        ModuleDescriptor descriptor2 = newBuilder("m2")
187
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
188
                .build();
189

190
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
191

192
        Configuration cf1 = resolve(finder1, "m2");
193

194
        assertTrue(cf1.modules().size() == 2);
195
        assertTrue(cf1.findModule("m1").isPresent());
196
        assertTrue(cf1.findModule("m2").isPresent());
197
        assertTrue(cf1.parents().size() == 1);
198
        assertTrue(cf1.parents().get(0) == Configuration.empty());
199

200
        ResolvedModule m1 = cf1.findModule("m1").get();
201
        ResolvedModule m2 = cf1.findModule("m2").get();
202

203
        assertTrue(m1.reads().size() == 0);
204
        assertTrue(m2.reads().size() == 1);
205
        assertTrue(m2.reads().contains(m1));
206

207

208
        // cf2: m3, m3 requires m2
209

210
        ModuleDescriptor descriptor3 = newBuilder("m3")
211
                .requires("m2")
212
                .build();
213

214
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3);
215

216
        Configuration cf2 = resolve(cf1, finder2, "m3");
217

218
        assertTrue(cf2.modules().size() == 1);
219
        assertTrue(cf2.findModule("m1").isPresent());  // in parent
220
        assertTrue(cf2.findModule("m2").isPresent());  // in parent
221
        assertTrue(cf2.findModule("m3").isPresent());
222
        assertTrue(cf2.parents().size() == 1);
223
        assertTrue(cf2.parents().get(0) == cf1);
224

225
        ResolvedModule m3 = cf2.findModule("m3").get();
226
        assertTrue(m3.configuration() == cf2);
227
        assertTrue(m3.reads().size() == 2);
228
        assertTrue(m3.reads().contains(m1));
229
        assertTrue(m3.reads().contains(m2));
230
    }
231

232

233
    /**
234
     * Basic test of "requires transitive" with configurations.
235
     *
236
     * The test consists of three configurations:
237
     * - Configuration cf1: m1
238
     * - Configuration cf2: m2 requires transitive m1, m3 requires m2
239
     */
240
    public void testRequiresTransitive3() {
241

242
        // cf1: m1
243

244
        ModuleDescriptor descriptor1 = newBuilder("m1").build();
245

246
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
247

248
        Configuration cf1 = resolve(finder1, "m1");
249

250
        assertTrue(cf1.modules().size() == 1);
251
        assertTrue(cf1.findModule("m1").isPresent());
252
        assertTrue(cf1.parents().size() == 1);
253
        assertTrue(cf1.parents().get(0) == Configuration.empty());
254

255
        ResolvedModule m1 = cf1.findModule("m1").get();
256
        assertTrue(m1.reads().size() == 0);
257

258

259
        // cf2: m2, m3: m2 requires transitive m1, m3 requires m2
260

261
        ModuleDescriptor descriptor2 = newBuilder("m2")
262
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
263
                .build();
264

265
        ModuleDescriptor descriptor3 = newBuilder("m3")
266
                .requires("m2")
267
                .build();
268

269
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2, descriptor3);
270

271
        Configuration cf2 = resolve(cf1, finder2, "m3");
272

273
        assertTrue(cf2.modules().size() == 2);
274
        assertTrue(cf2.findModule("m1").isPresent());   // in parent
275
        assertTrue(cf2.findModule("m2").isPresent());
276
        assertTrue(cf2.findModule("m3").isPresent());
277
        assertTrue(cf2.parents().size() == 1);
278
        assertTrue(cf2.parents().get(0) == cf1);
279

280
        ResolvedModule m2 = cf2.findModule("m2").get();
281
        ResolvedModule m3 = cf2.findModule("m3").get();
282

283
        assertTrue(m2.configuration() == cf2);
284
        assertTrue(m2.reads().size() == 1);
285
        assertTrue(m2.reads().contains(m1));
286

287
        assertTrue(m3.configuration() == cf2);
288
        assertTrue(m3.reads().size() == 2);
289
        assertTrue(m3.reads().contains(m1));
290
        assertTrue(m3.reads().contains(m2));
291
    }
292

293

294
    /**
295
     * Basic test of "requires transitive" with configurations.
296
     *
297
     * The test consists of three configurations:
298
     * - Configuration cf1: m1
299
     * - Configuration cf2: m2 requires transitive m1
300
     * - Configuraiton cf3: m3 requires m2
301
     */
302
    public void testRequiresTransitive4() {
303

304
        // cf1: m1
305

306
        ModuleDescriptor descriptor1 = newBuilder("m1").build();
307

308
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
309

310
        Configuration cf1 = resolve(finder1, "m1");
311

312
        assertTrue(cf1.modules().size() == 1);
313
        assertTrue(cf1.findModule("m1").isPresent());
314
        assertTrue(cf1.parents().size() == 1);
315
        assertTrue(cf1.parents().get(0) == Configuration.empty());
316

317
        ResolvedModule m1 = cf1.findModule("m1").get();
318
        assertTrue(m1.reads().size() == 0);
319

320

321
        // cf2: m2 requires transitive m1
322

323
        ModuleDescriptor descriptor2 = newBuilder("m2")
324
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
325
                .build();
326

327
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
328

329
        Configuration cf2 = resolve(cf1, finder2, "m2");
330

331
        assertTrue(cf2.modules().size() == 1);
332
        assertTrue(cf2.findModule("m1").isPresent());  // in parent
333
        assertTrue(cf2.findModule("m2").isPresent());
334
        assertTrue(cf2.parents().size() == 1);
335
        assertTrue(cf2.parents().get(0) == cf1);
336

337
        ResolvedModule m2 = cf2.findModule("m2").get();
338

339
        assertTrue(m2.configuration() == cf2);
340
        assertTrue(m2.reads().size() == 1);
341
        assertTrue(m2.reads().contains(m1));
342

343

344
        // cf3: m3 requires m2
345

346
        ModuleDescriptor descriptor3 = newBuilder("m3")
347
                .requires("m2")
348
                .build();
349

350
        ModuleFinder finder3 = ModuleUtils.finderOf(descriptor3);
351

352
        Configuration cf3 = resolve(cf2, finder3, "m3");
353

354
        assertTrue(cf3.modules().size() == 1);
355
        assertTrue(cf3.findModule("m1").isPresent());  // in parent
356
        assertTrue(cf3.findModule("m2").isPresent());  // in parent
357
        assertTrue(cf3.findModule("m3").isPresent());
358
        assertTrue(cf3.parents().size() == 1);
359
        assertTrue(cf3.parents().get(0) == cf2);
360

361
        ResolvedModule m3 = cf3.findModule("m3").get();
362

363
        assertTrue(m3.configuration() == cf3);
364
        assertTrue(m3.reads().size() == 2);
365
        assertTrue(m3.reads().contains(m1));
366
        assertTrue(m3.reads().contains(m2));
367
    }
368

369

370
    /**
371
     * Basic test of "requires transitive" with configurations.
372
     *
373
     * The test consists of two configurations:
374
     * - Configuration cf1: m1, m2 requires transitive m1
375
     * - Configuration cf2: m3 requires transitive m2, m4 requires m3
376
     */
377
    public void testRequiresTransitive5() {
378

379
        // cf1: m1, m2 requires transitive m1
380

381
        ModuleDescriptor descriptor1 = newBuilder("m1")
382
                .build();
383

384
        ModuleDescriptor descriptor2 = newBuilder("m2")
385
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
386
                .build();
387

388
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
389

390
        Configuration cf1 = resolve(finder1, "m2");
391

392
        assertTrue(cf1.modules().size() == 2);
393
        assertTrue(cf1.findModule("m1").isPresent());
394
        assertTrue(cf1.findModule("m2").isPresent());
395
        assertTrue(cf1.parents().size() == 1);
396
        assertTrue(cf1.parents().get(0) == Configuration.empty());
397

398
        ResolvedModule m1 = cf1.findModule("m1").get();
399
        ResolvedModule m2 = cf1.findModule("m2").get();
400

401
        assertTrue(m1.configuration() == cf1);
402
        assertTrue(m1.reads().size() == 0);
403

404
        assertTrue(m2.configuration() == cf1);
405
        assertTrue(m2.reads().size() == 1);
406
        assertTrue(m2.reads().contains(m1));
407

408

409
        // cf2: m3 requires transitive m2, m4 requires m3
410

411
        ModuleDescriptor descriptor3 = newBuilder("m3")
412
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m2")
413
                .build();
414

415
        ModuleDescriptor descriptor4 = newBuilder("m4")
416
                .requires("m3")
417
                .build();
418

419

420
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3, descriptor4);
421

422
        Configuration cf2 = resolve(cf1, finder2, "m3", "m4");
423

424
        assertTrue(cf2.modules().size() == 2);
425
        assertTrue(cf2.findModule("m1").isPresent());   // in parent
426
        assertTrue(cf2.findModule("m2").isPresent());   // in parent
427
        assertTrue(cf2.findModule("m3").isPresent());
428
        assertTrue(cf2.findModule("m4").isPresent());
429
        assertTrue(cf2.parents().size() == 1);
430
        assertTrue(cf2.parents().get(0) == cf1);
431

432
        ResolvedModule m3 = cf2.findModule("m3").get();
433
        ResolvedModule m4 = cf2.findModule("m4").get();
434

435
        assertTrue(m3.configuration() == cf2);
436
        assertTrue(m3.reads().size() == 2);
437
        assertTrue(m3.reads().contains(m1));
438
        assertTrue(m3.reads().contains(m2));
439

440
        assertTrue(m4.configuration() == cf2);
441
        assertTrue(m4.reads().size() == 3);
442
        assertTrue(m4.reads().contains(m1));
443
        assertTrue(m4.reads().contains(m2));
444
        assertTrue(m4.reads().contains(m3));
445
    }
446

447

448
    /**
449
     * Basic test of "requires static":
450
     *     m1 requires static m2
451
     *     m2 is not observable
452
     *     resolve m1
453
     */
454
    public void testRequiresStatic1() {
455
        ModuleDescriptor descriptor1 = newBuilder("m1")
456
                .requires(Set.of(Requires.Modifier.STATIC), "m2")
457
                .build();
458

459
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
460

461
        Configuration cf = resolve(finder, "m1");
462

463
        assertTrue(cf.modules().size() == 1);
464

465
        ResolvedModule m1 = cf.findModule("m1").get();
466
        assertTrue(m1.reads().size() == 0);
467
    }
468

469

470
    /**
471
     * Basic test of "requires static":
472
     *     m1 requires static m2
473
     *     m2
474
     *     resolve m1
475
     */
476
    public void testRequiresStatic2() {
477
        ModuleDescriptor descriptor1 = newBuilder("m1")
478
                .requires(Set.of(Requires.Modifier.STATIC), "m2")
479
                .build();
480

481
        ModuleDescriptor descriptor2 = newBuilder("m2")
482
                .build();
483

484
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
485

486
        Configuration cf = resolve(finder, "m1");
487

488
        assertTrue(cf.modules().size() == 1);
489

490
        ResolvedModule m1 = cf.findModule("m1").get();
491
        assertTrue(m1.reads().size() == 0);
492
    }
493

494

495
    /**
496
     * Basic test of "requires static":
497
     *     m1 requires static m2
498
     *     m2
499
     *     resolve m1, m2
500
     */
501
    public void testRequiresStatic3() {
502
        ModuleDescriptor descriptor1 = newBuilder("m1")
503
                .requires(Set.of(Requires.Modifier.STATIC), "m2")
504
                .build();
505

506
        ModuleDescriptor descriptor2 = newBuilder("m2")
507
                .build();
508

509
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
510

511
        Configuration cf = resolve(finder, "m1", "m2");
512

513
        assertTrue(cf.modules().size() == 2);
514

515
        ResolvedModule m1 = cf.findModule("m1").get();
516
        ResolvedModule m2 = cf.findModule("m2").get();
517

518
        assertTrue(m1.reads().size() == 1);
519
        assertTrue(m1.reads().contains(m2));
520

521
        assertTrue(m2.reads().size() == 0);
522
    }
523

524

525
    /**
526
     * Basic test of "requires static":
527
     *     m1 requires m2, m3
528
     *     m2 requires static m2
529
     *     m3
530
     */
531
    public void testRequiresStatic4() {
532
        ModuleDescriptor descriptor1 = newBuilder("m1")
533
                .requires("m2")
534
                .requires("m3")
535
                .build();
536

537
        ModuleDescriptor descriptor2 = newBuilder("m2")
538
                .requires(Set.of(Requires.Modifier.STATIC), "m3")
539
                .build();
540

541
        ModuleDescriptor descriptor3 = newBuilder("m3")
542
                .build();
543

544
        ModuleFinder finder
545
            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
546

547
        Configuration cf = resolve(finder, "m1");
548

549
        assertTrue(cf.modules().size() == 3);
550

551
        ResolvedModule m1 = cf.findModule("m1").get();
552
        ResolvedModule m2 = cf.findModule("m2").get();
553
        ResolvedModule m3 = cf.findModule("m3").get();
554

555
        assertTrue(m1.reads().size() == 2);
556
        assertTrue(m1.reads().contains(m2));
557
        assertTrue(m1.reads().contains(m3));
558

559
        assertTrue(m2.reads().size() == 1);
560
        assertTrue(m2.reads().contains(m3));
561

562
        assertTrue(m3.reads().size() == 0);
563
    }
564

565

566
    /**
567
     * Basic test of "requires static":
568
     * The test consists of three configurations:
569
     * - Configuration cf1: m1, m2
570
     * - Configuration cf2: m3 requires m1, requires static m2
571
     */
572
    public void testRequiresStatic5() {
573
        ModuleDescriptor descriptor1 = newBuilder("m1")
574
                .build();
575

576
        ModuleDescriptor descriptor2 = newBuilder("m2")
577
                .build();
578

579
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
580

581
        Configuration cf1 = resolve(finder1, "m1", "m2");
582

583
        assertTrue(cf1.modules().size() == 2);
584
        assertTrue(cf1.findModule("m1").isPresent());
585
        assertTrue(cf1.findModule("m2").isPresent());
586

587
        ModuleDescriptor descriptor3 = newBuilder("m3")
588
                .requires("m1")
589
                .requires(Set.of(Requires.Modifier.STATIC), "m2")
590
                .build();
591

592
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3);
593

594
        Configuration cf2 = resolve(cf1, finder2, "m3");
595

596
        assertTrue(cf2.modules().size() == 1);
597
        assertTrue(cf2.findModule("m3").isPresent());
598

599
        ResolvedModule m1 = cf1.findModule("m1").get();
600
        ResolvedModule m2 = cf1.findModule("m2").get();
601
        ResolvedModule m3 = cf2.findModule("m3").get();
602

603
        assertTrue(m3.reads().size() == 2);
604
        assertTrue(m3.reads().contains(m1));
605
        assertTrue(m3.reads().contains(m2));
606
    }
607

608

609
    /**
610
     * Basic test of "requires static":
611
     * The test consists of three configurations:
612
     * - Configuration cf1: m1
613
     * - Configuration cf2: m3 requires m1, requires static m2
614
     */
615
    public void testRequiresStatic6() {
616
        ModuleDescriptor descriptor1 = newBuilder("m1")
617
                .build();
618

619
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
620

621
        Configuration cf1 = resolve(finder1, "m1");
622

623
        assertTrue(cf1.modules().size() == 1);
624
        assertTrue(cf1.findModule("m1").isPresent());
625

626
        ModuleDescriptor descriptor3 = newBuilder("m3")
627
                .requires("m1")
628
                .requires(Set.of(Requires.Modifier.STATIC), "m2")
629
                .build();
630

631
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3);
632

633
        Configuration cf2 = resolve(cf1, finder2, "m3");
634

635
        assertTrue(cf2.modules().size() == 1);
636
        assertTrue(cf2.findModule("m3").isPresent());
637

638
        ResolvedModule m1 = cf1.findModule("m1").get();
639
        ResolvedModule m3 = cf2.findModule("m3").get();
640

641
        assertTrue(m3.reads().size() == 1);
642
        assertTrue(m3.reads().contains(m1));
643
    }
644

645

646
    /**
647
     * Basic test of "requires static":
648
     *     (m1 not observable)
649
     *     m2 requires transitive static m1
650
     *     m3 requires m2
651
     */
652
    public void testRequiresStatic7() {
653
        ModuleDescriptor descriptor1 = null;  // not observable
654

655
        ModuleDescriptor descriptor2 = newBuilder("m2")
656
                .requires(Set.of(Requires.Modifier.TRANSITIVE,
657
                                Requires.Modifier.STATIC),
658
                         "m1")
659
                .build();
660

661
        ModuleDescriptor descriptor3 = newBuilder("m3")
662
                .requires("m2")
663
                .build();
664

665
        ModuleFinder finder = ModuleUtils.finderOf(descriptor2, descriptor3);
666

667
        Configuration cf = resolve(finder, "m3");
668

669
        assertTrue(cf.modules().size() == 2);
670
        assertTrue(cf.findModule("m2").isPresent());
671
        assertTrue(cf.findModule("m3").isPresent());
672
        ResolvedModule m2 = cf.findModule("m2").get();
673
        ResolvedModule m3 = cf.findModule("m3").get();
674
        assertTrue(m2.reads().isEmpty());
675
        assertTrue(m3.reads().size() == 1);
676
        assertTrue(m3.reads().contains(m2));
677
    }
678

679

680
    /**
681
     * Basic test of "requires static":
682
     * - Configuration cf1: m2 requires transitive static m1
683
     * - Configuration cf2: m3 requires m2
684
     */
685
    public void testRequiresStatic8() {
686
        ModuleDescriptor descriptor1 = null;  // not observable
687

688
        ModuleDescriptor descriptor2 = newBuilder("m2")
689
                .requires(Set.of(Requires.Modifier.TRANSITIVE,
690
                                Requires.Modifier.STATIC),
691
                        "m1")
692
                .build();
693

694
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor2);
695

696
        Configuration cf1 = resolve(finder1, "m2");
697

698
        assertTrue(cf1.modules().size() == 1);
699
        assertTrue(cf1.findModule("m2").isPresent());
700
        ResolvedModule m2 = cf1.findModule("m2").get();
701
        assertTrue(m2.reads().isEmpty());
702

703
        ModuleDescriptor descriptor3 = newBuilder("m3")
704
                .requires("m2")
705
                .build();
706

707
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3);
708

709
        Configuration cf2 = resolve(cf1, finder2, "m3");
710

711
        assertTrue(cf2.modules().size() == 1);
712
        assertTrue(cf2.findModule("m3").isPresent());
713
        ResolvedModule m3 = cf2.findModule("m3").get();
714
        assertTrue(m3.reads().size() == 1);
715
        assertTrue(m3.reads().contains(m2));
716
    }
717

718

719
    /**
720
     * Basic test of binding services
721
     *     m1 uses p.S
722
     *     m2 provides p.S
723
     */
724
    public void testServiceBinding1() {
725

726
        ModuleDescriptor descriptor1 = newBuilder("m1")
727
                .exports("p")
728
                .uses("p.S")
729
                .build();
730

731
        ModuleDescriptor descriptor2 = newBuilder("m2")
732
                .requires("m1")
733
                .provides("p.S", List.of("q.T"))
734
                .build();
735

736
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
737

738
        Configuration cf = resolveAndBind(finder, "m1");
739

740
        assertTrue(cf.modules().size() == 2);
741
        assertTrue(cf.findModule("m1").isPresent());
742
        assertTrue(cf.findModule("m2").isPresent());
743
        assertTrue(cf.parents().size() == 1);
744
        assertTrue(cf.parents().get(0) == Configuration.empty());
745

746
        ResolvedModule m1 = cf.findModule("m1").get();
747
        ResolvedModule m2 = cf.findModule("m2").get();
748

749
        assertTrue(m1.configuration() == cf);
750
        assertTrue(m1.reads().size() == 0);
751

752
        assertTrue(m2.configuration() == cf);
753
        assertTrue(m2.reads().size() == 1);
754
        assertTrue(m2.reads().contains(m1));
755
    }
756

757

758
    /**
759
     * Basic test of binding services
760
     *     m1 uses p.S1
761
     *     m2 provides p.S1, m2 uses p.S2
762
     *     m3 provides p.S2
763
     */
764
    public void testServiceBinding2() {
765

766
        ModuleDescriptor descriptor1 = newBuilder("m1")
767
                .exports("p")
768
                .uses("p.S1")
769
                .build();
770

771
        ModuleDescriptor descriptor2 = newBuilder("m2")
772
                .requires("m1")
773
                .uses("p.S2")
774
                .provides("p.S1", List.of("q.Service1Impl"))
775
                .build();
776

777
        ModuleDescriptor descriptor3 = newBuilder("m3")
778
                .requires("m1")
779
                .provides("p.S2", List.of("q.Service2Impl"))
780
                .build();
781

782
        ModuleFinder finder
783
            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
784

785
        Configuration cf = resolveAndBind(finder, "m1");
786

787
        assertTrue(cf.modules().size() == 3);
788
        assertTrue(cf.findModule("m1").isPresent());
789
        assertTrue(cf.findModule("m2").isPresent());
790
        assertTrue(cf.findModule("m3").isPresent());
791
        assertTrue(cf.parents().size() == 1);
792
        assertTrue(cf.parents().get(0) == Configuration.empty());
793

794
        ResolvedModule m1 = cf.findModule("m1").get();
795
        ResolvedModule m2 = cf.findModule("m2").get();
796
        ResolvedModule m3 = cf.findModule("m3").get();
797

798
        assertTrue(m1.configuration() == cf);
799
        assertTrue(m1.reads().size() == 0);
800

801
        assertTrue(m2.configuration() == cf);
802
        assertTrue(m2.reads().size() == 1);
803
        assertTrue(m2.reads().contains(m1));
804

805
        assertTrue(m3.configuration() == cf);
806
        assertTrue(m3.reads().size() == 1);
807
        assertTrue(m3.reads().contains(m1));
808
    }
809

810

811
    /**
812
     * Basic test of binding services with configurations.
813
     *
814
     * The test consists of two configurations:
815
     * - Configuration cf1: m1 uses p.S
816
     * - Configuration cf2: m2 provides p.S
817
     */
818
    public void testServiceBindingWithConfigurations1() {
819

820
        ModuleDescriptor descriptor1 = newBuilder("m1")
821
                .exports("p")
822
                .uses("p.S")
823
                .build();
824

825
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
826

827
        Configuration cf1 = resolve(finder1, "m1");
828

829
        assertTrue(cf1.modules().size() == 1);
830
        assertTrue(cf1.findModule("m1").isPresent());
831

832
        ModuleDescriptor descriptor2 = newBuilder("m2")
833
                .requires("m1")
834
                .provides("p.S", List.of("q.T"))
835
                .build();
836

837
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
838

839
        Configuration cf2 = resolveAndBind(cf1, finder2); // no roots
840

841
        assertTrue(cf2.parents().size() == 1);
842
        assertTrue(cf2.parents().get(0) == cf1);
843

844
        assertTrue(cf2.modules().size() == 1);
845
        assertTrue(cf2.findModule("m2").isPresent());
846

847
        ResolvedModule m1 = cf1.findModule("m1").get();
848
        ResolvedModule m2 = cf2.findModule("m2").get();
849

850
        assertTrue(m2.reads().size() == 1);
851
        assertTrue(m2.reads().contains(m1));
852
    }
853

854

855
    /**
856
     * Basic test of binding services with configurations.
857
     *
858
     * The test consists of two configurations:
859
     * - Configuration cf1: m1 uses p.S && provides p.S,
860
     *                      m2 provides p.S
861
     * - Configuration cf2: m3 provides p.S
862
     *                      m4 provides p.S
863
     */
864
    public void testServiceBindingWithConfigurations2() {
865

866
        ModuleDescriptor descriptor1 = newBuilder("m1")
867
                .exports("p")
868
                .uses("p.S")
869
                .provides("p.S", List.of("p1.ServiceImpl"))
870
                .build();
871

872
        ModuleDescriptor descriptor2 = newBuilder("m2")
873
                .requires("m1")
874
                .provides("p.S", List.of("p2.ServiceImpl"))
875
                .build();
876

877
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
878

879
        Configuration cf1 = resolveAndBind(finder1, "m1");
880

881
        assertTrue(cf1.modules().size() == 2);
882
        assertTrue(cf1.findModule("m1").isPresent());
883
        assertTrue(cf1.findModule("m2").isPresent());
884

885

886
        ModuleDescriptor descriptor3 = newBuilder("m3")
887
                .requires("m1")
888
                .provides("p.S", List.of("p3.ServiceImpl"))
889
                .build();
890

891
        ModuleDescriptor descriptor4 = newBuilder("m4")
892
                .requires("m1")
893
                .provides("p.S", List.of("p4.ServiceImpl"))
894
                .build();
895

896
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3, descriptor4);
897

898
        Configuration cf2 = resolveAndBind(cf1, finder2); // no roots
899

900
        assertTrue(cf2.parents().size() == 1);
901
        assertTrue(cf2.parents().get(0) == cf1);
902

903
        assertTrue(cf2.modules().size() == 2);
904
        assertTrue(cf2.findModule("m3").isPresent());
905
        assertTrue(cf2.findModule("m4").isPresent());
906

907
        ResolvedModule m1 = cf2.findModule("m1").get();  // should find in parent
908
        ResolvedModule m2 = cf2.findModule("m2").get();
909
        ResolvedModule m3 = cf2.findModule("m3").get();
910
        ResolvedModule m4 = cf2.findModule("m4").get();
911

912
        assertTrue(m1.reads().size() == 0);
913

914
        assertTrue(m2.reads().size() == 1);
915
        assertTrue(m2.reads().contains(m1));
916

917
        assertTrue(m3.reads().size() == 1);
918
        assertTrue(m3.reads().contains(m1));
919

920
        assertTrue(m4.reads().size() == 1);
921
        assertTrue(m4.reads().contains(m1));
922
    }
923

924

925
    /**
926
     * Basic test of binding services with configurations.
927
     *
928
     * Configuration cf1: [email protected] provides p.S
929
     * Test configuration cf2: m1 uses p.S, [email protected] provides p.S
930
     * Test configuration cf2: m1 uses p.S
931
     */
932
    public void testServiceBindingWithConfigurations3() {
933

934
        ModuleDescriptor service = newBuilder("s")
935
                .exports("p")
936
                .build();
937

938
        ModuleDescriptor provider_v1 = newBuilder("p")
939
                .version("1.0")
940
                .requires("s")
941
                .provides("p.S", List.of("q.T"))
942
                .build();
943

944
        ModuleFinder finder1 = ModuleUtils.finderOf(service, provider_v1);
945

946
        Configuration cf1 = resolve(finder1, "p");
947

948
        assertTrue(cf1.modules().size() == 2);
949
        assertTrue(cf1.findModule("s").isPresent());
950
        assertTrue(cf1.findModule("p").isPresent());
951

952
        // [email protected] in cf1
953
        ResolvedModule p = cf1.findModule("p").get();
954
        assertEquals(p.reference().descriptor(), provider_v1);
955

956

957
        ModuleDescriptor descriptor1 = newBuilder("m1")
958
                .requires("s")
959
                .uses("p.S")
960
                .build();
961

962
        ModuleDescriptor provider_v2 = newBuilder("p")
963
                .version("2.0")
964
                .requires("s")
965
                .provides("p.S", List.of("q.T"))
966
                .build();
967

968
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1, provider_v2);
969

970

971
        // finder2 is the before ModuleFinder and so [email protected] should be located
972

973
        Configuration cf2 = resolveAndBind(cf1, finder2, "m1");
974

975
        assertTrue(cf2.parents().size() == 1);
976
        assertTrue(cf2.parents().get(0) == cf1);
977
        assertTrue(cf2.modules().size() == 2);
978

979
        // p should be found in cf2
980
        p = cf2.findModule("p").get();
981
        assertTrue(p.configuration() == cf2);
982
        assertEquals(p.reference().descriptor(), provider_v2);
983

984

985
        // finder2 is the after ModuleFinder and so [email protected] should not be located
986
        // as module p is in parent configuration.
987

988
        cf2 = resolveAndBind(cf1, ModuleFinder.of(), finder2, "m1");
989

990
        assertTrue(cf2.parents().size() == 1);
991
        assertTrue(cf2.parents().get(0) == cf1);
992
        assertTrue(cf2.modules().size() == 1);
993

994
        // p should be found in cf1
995
        p = cf2.findModule("p").get();
996
        assertTrue(p.configuration() == cf1);
997
        assertEquals(p.reference().descriptor(), provider_v1);
998
    }
999

1000

1001
    /**
1002
     * Basic test with two module finders.
1003
     *
1004
     * Module m2 can be found by both the before and after finders.
1005
     */
1006
    public void testWithTwoFinders1() {
1007

1008
        ModuleDescriptor descriptor1 = newBuilder("m1")
1009
                .requires("m2")
1010
                .build();
1011

1012
        ModuleDescriptor descriptor2_v1 = newBuilder("m2")
1013
                .version("1.0")
1014
                .build();
1015

1016
        ModuleDescriptor descriptor2_v2 = newBuilder("m2")
1017
                .version("2.0")
1018
                .build();
1019

1020
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor2_v1);
1021
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1, descriptor2_v2);
1022

1023
        Configuration cf = resolve(finder1, finder2, "m1");
1024

1025
        assertTrue(cf.modules().size() == 2);
1026
        assertTrue(cf.findModule("m1").isPresent());
1027
        assertTrue(cf.findModule("m2").isPresent());
1028

1029
        ResolvedModule m1 = cf.findModule("m1").get();
1030
        ResolvedModule m2 = cf.findModule("m2").get();
1031

1032
        assertEquals(m1.reference().descriptor(), descriptor1);
1033
        assertEquals(m2.reference().descriptor(), descriptor2_v1);
1034
    }
1035

1036

1037
    /**
1038
     * Basic test with two modules finders and service binding.
1039
     *
1040
     * The before and after ModuleFinders both locate a service provider module
1041
     * named "m2" that provide implementations of the same service type.
1042
     */
1043
    public void testWithTwoFinders2() {
1044

1045
        ModuleDescriptor descriptor1 = newBuilder("m1")
1046
                .exports("p")
1047
                .uses("p.S")
1048
                .build();
1049

1050
        ModuleDescriptor descriptor2_v1 = newBuilder("m2")
1051
                .requires("m1")
1052
                .provides("p.S", List.of("q.T"))
1053
                .build();
1054

1055
        ModuleDescriptor descriptor2_v2 = newBuilder("m2")
1056
                .requires("m1")
1057
                .provides("p.S", List.of("q.T"))
1058
                .build();
1059

1060
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2_v1);
1061
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2_v2);
1062

1063
        Configuration cf = resolveAndBind(finder1, finder2, "m1");
1064

1065
        assertTrue(cf.modules().size() == 2);
1066
        assertTrue(cf.findModule("m1").isPresent());
1067
        assertTrue(cf.findModule("m2").isPresent());
1068

1069
        ResolvedModule m1 = cf.findModule("m1").get();
1070
        ResolvedModule m2 = cf.findModule("m2").get();
1071

1072
        assertEquals(m1.reference().descriptor(), descriptor1);
1073
        assertEquals(m2.reference().descriptor(), descriptor2_v1);
1074
    }
1075

1076

1077
    /**
1078
     * Basic test for resolving a module that is located in the parent
1079
     * configuration.
1080
     */
1081
    public void testResolvedInParent1() {
1082

1083
        ModuleDescriptor descriptor1 = newBuilder("m1")
1084
                .build();
1085

1086
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
1087

1088
        Configuration cf1 = resolve(finder, "m1");
1089

1090
        assertTrue(cf1.modules().size() == 1);
1091
        assertTrue(cf1.findModule("m1").isPresent());
1092

1093
        Configuration cf2 = resolve(cf1, finder, "m1");
1094

1095
        assertTrue(cf2.modules().size() == 1);
1096
    }
1097

1098

1099
    /**
1100
     * Basic test for resolving a module that has a dependency on a module
1101
     * in the parent configuration.
1102
     */
1103
    public void testResolvedInParent2() {
1104

1105
        ModuleDescriptor descriptor1 = newBuilder("m1").build();
1106

1107
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
1108

1109
        Configuration cf1 = resolve(finder1, "m1");
1110

1111
        assertTrue(cf1.modules().size() == 1);
1112
        assertTrue(cf1.findModule("m1").isPresent());
1113

1114

1115
        ModuleDescriptor descriptor2 = newBuilder("m2")
1116
                .requires("m1")
1117
                .build();
1118

1119
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
1120

1121
        Configuration cf2 = resolve(cf1, ModuleFinder.of(), finder2, "m2");
1122

1123
        assertTrue(cf2.modules().size() == 1);
1124
        assertTrue(cf2.findModule("m2").isPresent());
1125

1126
        ResolvedModule m1 = cf2.findModule("m1").get();   // find in parent
1127
        ResolvedModule m2 = cf2.findModule("m2").get();
1128

1129
        assertTrue(m1.reads().size() == 0);
1130
        assertTrue(m2.reads().size() == 1);
1131
        assertTrue(m2.reads().contains(m1));
1132
    }
1133

1134

1135
    /**
1136
     * Basic test of resolving a module that depends on modules in two parent
1137
     * configurations.
1138
     *
1139
     * The test consists of three configurations:
1140
     * - Configuration cf1: m1
1141
     * - Configuration cf2: m2
1142
     * - Configuration cf3(cf1,cf2): m3 requires m1, m2
1143
     */
1144
    public void testResolvedInMultipleParents1() {
1145

1146
        // Configuration cf1: m1
1147
        ModuleDescriptor descriptor1 = newBuilder("m1").build();
1148
        Configuration cf1 = resolve(ModuleUtils.finderOf(descriptor1), "m1");
1149
        assertEquals(cf1.parents(), List.of(Configuration.empty()));
1150
        assertTrue(cf1.findModule("m1").isPresent());
1151
        ResolvedModule m1 = cf1.findModule("m1").get();
1152
        assertTrue(m1.configuration() == cf1);
1153

1154
        // Configuration cf2: m2
1155
        ModuleDescriptor descriptor2 = newBuilder("m2").build();
1156
        Configuration cf2 = resolve(ModuleUtils.finderOf(descriptor2), "m2");
1157
        assertEquals(cf2.parents(), List.of(Configuration.empty()));
1158
        assertTrue(cf2.findModule("m2").isPresent());
1159
        ResolvedModule m2 = cf2.findModule("m2").get();
1160
        assertTrue(m2.configuration() == cf2);
1161

1162
        // Configuration cf3(cf1,cf2): m3 requires m1 and m2
1163
        ModuleDescriptor descriptor3 = newBuilder("m3")
1164
                .requires("m1")
1165
                .requires("m2")
1166
                .build();
1167
        ModuleFinder finder = ModuleUtils.finderOf(descriptor3);
1168
        Configuration cf3 = Configuration.resolve(
1169
                finder,
1170
                List.of(cf1, cf2),  // parents
1171
                ModuleFinder.of(),
1172
                Set.of("m3"));
1173
        assertEquals(cf3.parents(), List.of(cf1, cf2));
1174
        assertTrue(cf3.findModule("m3").isPresent());
1175
        ResolvedModule m3 = cf3.findModule("m3").get();
1176
        assertTrue(m3.configuration() == cf3);
1177

1178
        // check readability
1179
        assertTrue(m1.reads().isEmpty());
1180
        assertTrue(m2.reads().isEmpty());
1181
        assertEquals(m3.reads(), Set.of(m1, m2));
1182
    }
1183

1184

1185
    /**
1186
     * Basic test of resolving a module that depends on modules in three parent
1187
     * configurations arranged in a diamond (two direct parents).
1188
     *
1189
     * The test consists of four configurations:
1190
     * - Configuration cf1: m1
1191
     * - Configuration cf2(cf1): m2 requires m1
1192
     * - Configuration cf3(cf3): m3 requires m1
1193
     * - Configuration cf4(cf2,cf3): m4 requires m1,m2,m3
1194
     */
1195
    public void testResolvedInMultipleParents2() {
1196
        // Configuration cf1: m1
1197
        ModuleDescriptor descriptor1 = newBuilder("m1").build();
1198
        Configuration cf1 = resolve(ModuleUtils.finderOf(descriptor1), "m1");
1199
        assertEquals(cf1.parents(), List.of(Configuration.empty()));
1200
        assertTrue(cf1.findModule("m1").isPresent());
1201
        ResolvedModule m1 = cf1.findModule("m1").get();
1202
        assertTrue(m1.configuration() == cf1);
1203

1204
        // Configuration cf2(cf1): m2 requires m1
1205
        ModuleDescriptor descriptor2 = newBuilder("m2")
1206
                .requires("m1")
1207
                .build();
1208
        Configuration cf2 = Configuration.resolve(
1209
                ModuleUtils.finderOf(descriptor2),
1210
                List.of(cf1),  // parents
1211
                ModuleFinder.of(),
1212
                Set.of("m2"));
1213
        assertEquals(cf2.parents(), List.of(cf1));
1214
        assertTrue(cf2.findModule("m2").isPresent());
1215
        ResolvedModule m2 = cf2.findModule("m2").get();
1216
        assertTrue(m2.configuration() == cf2);
1217

1218
        // Configuration cf3(cf1): m3 requires m1
1219
        ModuleDescriptor descriptor3 = newBuilder("m3")
1220
                .requires("m1")
1221
                .build();
1222
        Configuration cf3 = Configuration.resolve(
1223
                ModuleUtils.finderOf(descriptor3),
1224
                List.of(cf1),  // parents
1225
                ModuleFinder.of(),
1226
                Set.of("m3"));
1227
        assertEquals(cf3.parents(), List.of(cf1));
1228
        assertTrue(cf3.findModule("m3").isPresent());
1229
        ResolvedModule m3 = cf3.findModule("m3").get();
1230
        assertTrue(m3.configuration() == cf3);
1231

1232
        // Configuration cf4(cf2,cf3): m4 requires m1,m2,m3
1233
        ModuleDescriptor descriptor4 = newBuilder("m4")
1234
                .requires("m1")
1235
                .requires("m2")
1236
                .requires("m3")
1237
                .build();
1238
        Configuration cf4 = Configuration.resolve(
1239
                ModuleUtils.finderOf(descriptor4),
1240
                List.of(cf2, cf3),  // parents
1241
                ModuleFinder.of(),
1242
                Set.of("m4"));
1243
        assertEquals(cf4.parents(), List.of(cf2, cf3));
1244
        assertTrue(cf4.findModule("m4").isPresent());
1245
        ResolvedModule m4 = cf4.findModule("m4").get();
1246
        assertTrue(m4.configuration() == cf4);
1247

1248
        // check readability
1249
        assertTrue(m1.reads().isEmpty());
1250
        assertEquals(m2.reads(), Set.of(m1));
1251
        assertEquals(m3.reads(), Set.of(m1));
1252
        assertEquals(m4.reads(), Set.of(m1, m2, m3));
1253
    }
1254

1255

1256
    /**
1257
     * Basic test of resolving a module that depends on modules in three parent
1258
     * configurations arranged in a diamond (two direct parents).
1259
     *
1260
     * The test consists of four configurations:
1261
     * - Configuration cf1: m1@1
1262
     * - Configuration cf2: m1@2, m2@2
1263
     * - Configuration cf3: m1@3, m2@3, m3@3
1264
     * - Configuration cf4(cf1,cf2,cf3): m4 requires m1,m2,m3
1265
     */
1266
    public void testResolvedInMultipleParents3() {
1267
        ModuleDescriptor descriptor1, descriptor2, descriptor3;
1268

1269
        // Configuration cf1: m1@1
1270
        descriptor1 = newBuilder("m1").version("1").build();
1271
        Configuration cf1 = resolve(ModuleUtils.finderOf(descriptor1), "m1");
1272
        assertEquals(cf1.parents(), List.of(Configuration.empty()));
1273

1274
        // Configuration cf2: m1@2, m2@2
1275
        descriptor1 = newBuilder("m1").version("2").build();
1276
        descriptor2 = newBuilder("m2").version("2").build();
1277
        Configuration cf2 = resolve(
1278
                ModuleUtils.finderOf(descriptor1, descriptor2),
1279
                "m1", "m2");
1280
        assertEquals(cf2.parents(), List.of(Configuration.empty()));
1281

1282
        // Configuration cf3: m1@3, m2@3, m3@3
1283
        descriptor1 = newBuilder("m1").version("3").build();
1284
        descriptor2 = newBuilder("m2").version("3").build();
1285
        descriptor3 = newBuilder("m3").version("3").build();
1286
        Configuration cf3 = resolve(
1287
                ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3),
1288
                "m1", "m2", "m3");
1289
        assertEquals(cf3.parents(), List.of(Configuration.empty()));
1290

1291
        // Configuration cf4(cf1,cf2,cf3): m4 requires m1,m2,m3
1292
        ModuleDescriptor descriptor4 = newBuilder("m4")
1293
                .requires("m1")
1294
                .requires("m2")
1295
                .requires("m3")
1296
                .build();
1297
        Configuration cf4 = Configuration.resolve(
1298
                ModuleUtils.finderOf(descriptor4),
1299
                List.of(cf1, cf2, cf3),  // parents
1300
                ModuleFinder.of(),
1301
                Set.of("m4"));
1302
        assertEquals(cf4.parents(), List.of(cf1, cf2, cf3));
1303

1304
        assertTrue(cf1.findModule("m1").isPresent());
1305
        assertTrue(cf2.findModule("m1").isPresent());
1306
        assertTrue(cf2.findModule("m2").isPresent());
1307
        assertTrue(cf3.findModule("m1").isPresent());
1308
        assertTrue(cf3.findModule("m2").isPresent());
1309
        assertTrue(cf3.findModule("m3").isPresent());
1310
        assertTrue(cf4.findModule("m4").isPresent());
1311

1312
        ResolvedModule m1_1 = cf1.findModule("m1").get();
1313
        ResolvedModule m1_2 = cf2.findModule("m1").get();
1314
        ResolvedModule m2_2 = cf2.findModule("m2").get();
1315
        ResolvedModule m1_3 = cf3.findModule("m1").get();
1316
        ResolvedModule m2_3 = cf3.findModule("m2").get();
1317
        ResolvedModule m3_3 = cf3.findModule("m3").get();
1318
        ResolvedModule m4   = cf4.findModule("m4").get();
1319

1320
        assertTrue(m1_1.configuration() == cf1);
1321
        assertTrue(m1_2.configuration() == cf2);
1322
        assertTrue(m2_2.configuration() == cf2);
1323
        assertTrue(m1_3.configuration() == cf3);
1324
        assertTrue(m2_3.configuration() == cf3);
1325
        assertTrue(m3_3.configuration() == cf3);
1326
        assertTrue(m4.configuration() == cf4);
1327

1328
        // check readability
1329
        assertTrue(m1_1.reads().isEmpty());
1330
        assertTrue(m1_2.reads().isEmpty());
1331
        assertTrue(m2_2.reads().isEmpty());
1332
        assertTrue(m1_3.reads().isEmpty());
1333
        assertTrue(m2_3.reads().isEmpty());
1334
        assertTrue(m3_3.reads().isEmpty());
1335
        assertEquals(m4.reads(), Set.of(m1_1, m2_2, m3_3));
1336
    }
1337

1338

1339
    /**
1340
     * Basic test of using the beforeFinder to override a module in a parent
1341
     * configuration.
1342
     */
1343
    public void testOverriding1() {
1344
        ModuleDescriptor descriptor1 = newBuilder("m1").build();
1345

1346
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
1347

1348
        Configuration cf1 = resolve(finder, "m1");
1349
        assertTrue(cf1.modules().size() == 1);
1350
        assertTrue(cf1.findModule("m1").isPresent());
1351

1352
        Configuration cf2 = resolve(cf1, finder, "m1");
1353
        assertTrue(cf2.modules().size() == 1);
1354
        assertTrue(cf2.findModule("m1").isPresent());
1355
    }
1356

1357
    /**
1358
     * Basic test of using the beforeFinder to override a module in a parent
1359
     * configuration.
1360
     */
1361
    public void testOverriding2() {
1362
        ModuleDescriptor descriptor1 = newBuilder("m1").build();
1363
        Configuration cf1 = resolve(ModuleUtils.finderOf(descriptor1), "m1");
1364
        assertTrue(cf1.modules().size() == 1);
1365
        assertTrue(cf1.findModule("m1").isPresent());
1366

1367
        ModuleDescriptor descriptor2 = newBuilder("m2").build();
1368
        Configuration cf2 = resolve(ModuleUtils.finderOf(descriptor2), "m2");
1369
        assertTrue(cf2.modules().size() == 1);
1370
        assertTrue(cf2.findModule("m2").isPresent());
1371

1372
        ModuleDescriptor descriptor3 = newBuilder("m3").build();
1373
        Configuration cf3 = resolve(ModuleUtils.finderOf(descriptor3), "m3");
1374
        assertTrue(cf3.modules().size() == 1);
1375
        assertTrue(cf3.findModule("m3").isPresent());
1376

1377
        // override m2, m1 and m3 should be found in parent configurations
1378
        ModuleFinder finder = ModuleUtils.finderOf(descriptor2);
1379
        Configuration cf4 = Configuration.resolve(
1380
                finder,
1381
                List.of(cf1, cf2, cf3),
1382
                ModuleFinder.of(),
1383
                Set.of("m1", "m2", "m3"));
1384
        assertTrue(cf4.modules().size() == 1);
1385
        assertTrue(cf4.findModule("m2").isPresent());
1386
        ResolvedModule m2 = cf4.findModule("m2").get();
1387
        assertTrue(m2.configuration() == cf4);
1388
    }
1389

1390

1391
    /**
1392
     * Basic test of using the beforeFinder to override a module in the parent
1393
     * configuration but where implied readability in the picture so that the
1394
     * module in the parent is read.
1395
     *
1396
     * The test consists of two configurations:
1397
     * - Configuration cf1: m1, m2 requires transitive m1
1398
     * - Configuration cf2: m1, m3 requires m2
1399
     */
1400
    public void testOverriding3() {
1401

1402
        ModuleDescriptor descriptor1 = newBuilder("m1")
1403
                .build();
1404

1405
        ModuleDescriptor descriptor2 = newBuilder("m2")
1406
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
1407
                .build();
1408

1409
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
1410

1411
        Configuration cf1 = resolve(finder1, "m2");
1412

1413
        assertTrue(cf1.modules().size() == 2);
1414
        assertTrue(cf1.findModule("m1").isPresent());
1415
        assertTrue(cf1.findModule("m2").isPresent());
1416

1417
        // cf2: m3 requires m2, m1
1418

1419
        ModuleDescriptor descriptor3 = newBuilder("m3")
1420
                .requires("m2")
1421
                .build();
1422

1423
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1, descriptor3);
1424

1425
        Configuration cf2 = resolve(cf1, finder2, "m1", "m3");
1426

1427
        assertTrue(cf2.parents().size() == 1);
1428
        assertTrue(cf2.parents().get(0) == cf1);
1429

1430
        assertTrue(cf2.modules().size() == 2);
1431
        assertTrue(cf2.findModule("m1").isPresent());
1432
        assertTrue(cf2.findModule("m3").isPresent());
1433

1434
        ResolvedModule m1_1 = cf1.findModule("m1").get();
1435
        ResolvedModule m1_2 = cf2.findModule("m1").get();
1436
        ResolvedModule m2 = cf1.findModule("m2").get();
1437
        ResolvedModule m3 = cf2.findModule("m3").get();
1438

1439
        assertTrue(m1_1.configuration() == cf1);
1440
        assertTrue(m1_2.configuration() == cf2);
1441
        assertTrue(m3.configuration() == cf2);
1442

1443

1444
        // check that m3 reads cf1/m1 and cf2/m2
1445
        assertTrue(m3.reads().size() == 2);
1446
        assertTrue(m3.reads().contains(m1_1));
1447
        assertTrue(m3.reads().contains(m2));
1448
    }
1449

1450

1451
    /**
1452
     * Root module not found
1453
     */
1454
    @Test(expectedExceptions = { FindException.class })
1455
    public void testRootNotFound() {
1456
        resolve(ModuleFinder.of(), "m1");
1457
    }
1458

1459

1460
    /**
1461
     * Direct dependency not found
1462
     */
1463
    @Test(expectedExceptions = { FindException.class })
1464
    public void testDirectDependencyNotFound() {
1465
        ModuleDescriptor descriptor1 = newBuilder("m1").requires("m2").build();
1466
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
1467
        resolve(finder, "m1");
1468
    }
1469

1470

1471
    /**
1472
     * Transitive dependency not found
1473
     */
1474
    @Test(expectedExceptions = { FindException.class })
1475
    public void testTransitiveDependencyNotFound() {
1476
        ModuleDescriptor descriptor1 = newBuilder("m1").requires("m2").build();
1477
        ModuleDescriptor descriptor2 = newBuilder("m2").requires("m3").build();
1478
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
1479
        resolve(finder, "m1");
1480
    }
1481

1482

1483
    /**
1484
     * Service provider dependency not found
1485
     */
1486
    @Test(expectedExceptions = { FindException.class })
1487
    public void testServiceProviderDependencyNotFound() {
1488

1489
        // service provider dependency (on m3) not found
1490

1491
        ModuleDescriptor descriptor1 = newBuilder("m1")
1492
                .exports("p")
1493
                .uses("p.S")
1494
                .build();
1495

1496
        ModuleDescriptor descriptor2 = newBuilder("m2")
1497
                .requires("m1")
1498
                .requires("m3")
1499
                .provides("p.S", List.of("q.T"))
1500
                .build();
1501

1502
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
1503

1504
        // should throw ResolutionException because m3 is not found
1505
        Configuration cf = resolveAndBind(finder, "m1");
1506
    }
1507

1508

1509
    /**
1510
     * Simple cycle.
1511
     */
1512
    @Test(expectedExceptions = { ResolutionException.class })
1513
    public void testSimpleCycle() {
1514
        ModuleDescriptor descriptor1 = newBuilder("m1").requires("m2").build();
1515
        ModuleDescriptor descriptor2 = newBuilder("m2").requires("m3").build();
1516
        ModuleDescriptor descriptor3 = newBuilder("m3").requires("m1").build();
1517
        ModuleFinder finder
1518
            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
1519
        resolve(finder, "m1");
1520
    }
1521

1522
    /**
1523
     * Basic test for detecting cycles involving a service provider module
1524
     */
1525
    @Test(expectedExceptions = { ResolutionException.class })
1526
    public void testCycleInProvider() {
1527

1528
        ModuleDescriptor descriptor1 = newBuilder("m1")
1529
                .exports("p")
1530
                .uses("p.S")
1531
                .build();
1532
        ModuleDescriptor descriptor2 = newBuilder("m2")
1533
                .requires("m1")
1534
                .requires("m3")
1535
                .provides("p.S", List.of("q.T"))
1536
                .build();
1537
        ModuleDescriptor descriptor3 = newBuilder("m3")
1538
                .requires("m2")
1539
                .build();
1540

1541
        ModuleFinder finder
1542
            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
1543

1544
        // should throw ResolutionException because of the m2 <--> m3 cycle
1545
        resolveAndBind(finder, "m1");
1546
    }
1547

1548

1549
    /**
1550
     * Basic test to detect reading a module with the same name as itself
1551
     *
1552
     * The test consists of three configurations:
1553
     * - Configuration cf1: m1, m2 requires transitive m1
1554
     * - Configuration cf2: m1 requires m2
1555
     */
1556
    @Test(expectedExceptions = { ResolutionException.class })
1557
    public void testReadModuleWithSameNameAsSelf() {
1558
        ModuleDescriptor descriptor1_v1 = newBuilder("m1")
1559
                .build();
1560

1561
        ModuleDescriptor descriptor2 = newBuilder("m2")
1562
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
1563
                .build();
1564

1565
        ModuleDescriptor descriptor1_v2 = newBuilder("m1")
1566
                .requires("m2")
1567
                .build();
1568

1569
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1_v1, descriptor2);
1570
        Configuration cf1 = resolve(finder1, "m2");
1571
        assertTrue(cf1.modules().size() == 2);
1572

1573
        // resolve should throw ResolutionException
1574
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1_v2);
1575
        resolve(cf1, finder2, "m1");
1576
    }
1577

1578

1579
    /**
1580
     * Basic test to detect reading two modules with the same name
1581
     *
1582
     * The test consists of three configurations:
1583
     * - Configuration cf1: m1, m2 requires transitive m1
1584
     * - Configuration cf2: m1, m3 requires transitive m1
1585
     * - Configuration cf3(cf1,cf2): m4 requires m2, m3
1586
     */
1587
    @Test(expectedExceptions = { ResolutionException.class })
1588
    public void testReadTwoModuleWithSameName() {
1589
        ModuleDescriptor descriptor1 = newBuilder("m1")
1590
                .build();
1591

1592
        ModuleDescriptor descriptor2 = newBuilder("m2")
1593
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
1594
                .build();
1595

1596
        ModuleDescriptor descriptor3 = newBuilder("m3")
1597
                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
1598
                .build();
1599

1600
        ModuleDescriptor descriptor4 = newBuilder("m4")
1601
                .requires("m2")
1602
                .requires("m3")
1603
                .build();
1604

1605
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
1606
        Configuration cf1 = resolve(finder1, "m2");
1607
        assertTrue(cf1.modules().size() == 2);
1608

1609
        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1, descriptor3);
1610
        Configuration cf2 = resolve(finder2, "m3");
1611
        assertTrue(cf2.modules().size() == 2);
1612

1613
        // should throw ResolutionException as m4 will read modules named "m1".
1614
        ModuleFinder finder3 = ModuleUtils.finderOf(descriptor4);
1615
        Configuration.resolve(finder3, List.of(cf1, cf2), ModuleFinder.of(), Set.of("m4"));
1616
    }
1617

1618

1619
    /**
1620
     * Test two modules exporting package p to a module that reads both.
1621
     */
1622
    @Test(expectedExceptions = { ResolutionException.class })
1623
    public void testPackageSuppliedByTwoOthers() {
1624

1625
        ModuleDescriptor descriptor1 = newBuilder("m1")
1626
                .requires("m2")
1627
                .requires("m3")
1628
                .build();
1629

1630
        ModuleDescriptor descriptor2 = newBuilder("m2")
1631
                .exports("p")
1632
                .build();
1633

1634
        ModuleDescriptor descriptor3 = newBuilder("m3")
1635
                .exports("p", Set.of("m1"))
1636
                .build();
1637

1638
        ModuleFinder finder
1639
            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
1640

1641
        // m2 and m3 export package p to module m1
1642
        resolve(finder, "m1");
1643
    }
1644

1645

1646
    /**
1647
     * Test the scenario where a module contains a package p and reads
1648
     * a module that exports package p.
1649
     */
1650
    @Test(expectedExceptions = { ResolutionException.class })
1651
    public void testPackageSuppliedBySelfAndOther() {
1652

1653
        ModuleDescriptor descriptor1 = newBuilder("m1")
1654
                .requires("m2")
1655
                .packages(Set.of("p"))
1656
                .build();
1657

1658
        ModuleDescriptor descriptor2 = newBuilder("m2")
1659
                .exports("p")
1660
                .build();
1661

1662
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
1663

1664
        // m1 contains package p, module m2 exports package p to m1
1665
        resolve(finder, "m1");
1666
    }
1667

1668

1669
    /**
1670
     * Test the scenario where a module contains a package p and reads
1671
     * a module that also contains a package p.
1672
     */
1673
    public void testContainsPackageInSelfAndOther() {
1674
        ModuleDescriptor descriptor1 = newBuilder("m1")
1675
                .requires("m2")
1676
                .packages(Set.of("p"))
1677
                .build();
1678

1679
        ModuleDescriptor descriptor2 = newBuilder("m2")
1680
                .packages(Set.of("p"))
1681
                .build();
1682

1683
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
1684

1685
        Configuration cf = resolve(finder, "m1");
1686

1687
        assertTrue(cf.modules().size() == 2);
1688
        assertTrue(cf.findModule("m1").isPresent());
1689
        assertTrue(cf.findModule("m2").isPresent());
1690

1691
        // m1 reads m2, m2 reads nothing
1692
        ResolvedModule m1 = cf.findModule("m1").get();
1693
        ResolvedModule m2 = cf.findModule("m2").get();
1694
        assertTrue(m1.reads().size() == 1);
1695
        assertTrue(m1.reads().contains(m2));
1696
        assertTrue(m2.reads().size() == 0);
1697
    }
1698

1699

1700
    /**
1701
     * Test the scenario where a module that exports a package that is also
1702
     * exported by a module that it reads in a parent layer.
1703
     */
1704
    @Test(expectedExceptions = { ResolutionException.class })
1705
    public void testExportSamePackageAsBootLayer() {
1706
        ModuleDescriptor descriptor = newBuilder("m1")
1707
                .requires("java.base")
1708
                .exports("java.lang")
1709
                .build();
1710

1711
        ModuleFinder finder = ModuleUtils.finderOf(descriptor);
1712

1713
        Configuration bootConfiguration = ModuleLayer.boot().configuration();
1714

1715
        // m1 contains package java.lang, java.base exports package java.lang to m1
1716
        resolve(bootConfiguration, finder, "m1");
1717
    }
1718

1719

1720
    /**
1721
     * Test "uses p.S" where p is contained in the same module.
1722
     */
1723
    public void testContainsService1() {
1724
        ModuleDescriptor descriptor1 = newBuilder("m1")
1725
                .packages(Set.of("p"))
1726
                .uses("p.S")
1727
                .build();
1728

1729
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
1730

1731
        Configuration cf = resolve(finder, "m1");
1732

1733
        assertTrue(cf.modules().size() == 1);
1734
        assertTrue(cf.findModule("m1").isPresent());
1735
    }
1736

1737

1738
    /**
1739
     * Test "uses p.S" where p is contained in a different module.
1740
     */
1741
    @Test(expectedExceptions = { ResolutionException.class })
1742
    public void testContainsService2() {
1743
        ModuleDescriptor descriptor1 = newBuilder("m1")
1744
                .packages(Set.of("p"))
1745
                .build();
1746

1747
        ModuleDescriptor descriptor2 = newBuilder("m2")
1748
                .requires("m1")
1749
                .uses("p.S")
1750
                .build();
1751

1752
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
1753

1754
        // m2 does not read a module that exports p
1755
        resolve(finder, "m2");
1756
    }
1757

1758

1759
    /**
1760
     * Test "provides p.S" where p is contained in the same module.
1761
     */
1762
    public void testContainsService3() {
1763
        ModuleDescriptor descriptor1 = newBuilder("m1")
1764
                .packages(Set.of("p", "q"))
1765
                .provides("p.S", List.of("q.S1"))
1766
                .build();
1767

1768
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
1769

1770
        Configuration cf = resolve(finder, "m1");
1771

1772
        assertTrue(cf.modules().size() == 1);
1773
        assertTrue(cf.findModule("m1").isPresent());
1774
    }
1775

1776

1777
    /**
1778
     * Test "provides p.S" where p is contained in a different module.
1779
     */
1780
    @Test(expectedExceptions = { ResolutionException.class })
1781
    public void testContainsService4() {
1782
        ModuleDescriptor descriptor1 = newBuilder("m1")
1783
                .packages(Set.of("p"))
1784
                .build();
1785

1786
        ModuleDescriptor descriptor2 = newBuilder("m2")
1787
                .requires("m1")
1788
                .provides("p.S", List.of("q.S1"))
1789
                .build();
1790

1791
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
1792

1793
        // m2 does not read a module that exports p
1794
        resolve(finder, "m2");
1795
    }
1796

1797

1798
    /**
1799
     * Test "uses p.S" where p is not exported to the module.
1800
     */
1801
    @Test(expectedExceptions = { ResolutionException.class })
1802
    public void testServiceTypePackageNotExported1() {
1803
        ModuleDescriptor descriptor1 = newBuilder("m1")
1804
                .uses("p.S")
1805
                .build();
1806

1807
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
1808

1809
        // m1 does not read a module that exports p
1810
        resolve(finder, "m1");
1811
    }
1812

1813

1814
    /**
1815
     * Test "provides p.S" where p is not exported to the module.
1816
     */
1817
    @Test(expectedExceptions = { ResolutionException.class })
1818
    public void testServiceTypePackageNotExported2() {
1819
        ModuleDescriptor descriptor1 = newBuilder("m1")
1820
                .provides("p.S", List.of("q.T"))
1821
                .build();
1822

1823
        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);
1824

1825
        // m1 does not read a module that exports p
1826
        resolve(finder, "m1");
1827
    }
1828

1829

1830
    /**
1831
     * Test the empty configuration.
1832
     */
1833
    public void testEmptyConfiguration() {
1834
        Configuration cf = Configuration.empty();
1835

1836
        assertTrue(cf.parents().isEmpty());
1837

1838
        assertTrue(cf.modules().isEmpty());
1839
        assertFalse(cf.findModule("java.base").isPresent());
1840
    }
1841

1842

1843
    // platform specific modules
1844

1845
    @DataProvider(name = "platformmatch")
1846
    public Object[][] createPlatformMatches() {
1847
        return new Object[][]{
1848

1849
            { "",              "" },
1850
            { "linux-arm",     "" },
1851
            { "linux-arm",     "linux-arm" },
1852

1853
        };
1854

1855
    };
1856

1857
    @DataProvider(name = "platformmismatch")
1858
    public Object[][] createBad() {
1859
        return new Object[][] {
1860

1861
            { "linux-x64",        "linux-arm" },
1862
            { "linux-x64",        "windows-x64" },
1863

1864
        };
1865
    }
1866

1867
    /**
1868
     * Test creating a configuration containing platform specific modules.
1869
     */
1870
    @Test(dataProvider = "platformmatch")
1871
    public void testPlatformMatch(String s1, String s2) throws IOException {
1872

1873
        ModuleDescriptor base =  ModuleDescriptor.newModule("java.base").build();
1874
        Path system = writeModule(base, null);
1875

1876
        ModuleDescriptor descriptor1 = ModuleDescriptor.newModule("m1")
1877
                .requires("m2")
1878
                .build();
1879
        Path dir1 = writeModule(descriptor1, s1);
1880

1881
        ModuleDescriptor descriptor2 = ModuleDescriptor.newModule("m2").build();
1882
        Path dir2 = writeModule(descriptor2, s2);
1883

1884
        ModuleFinder finder = ModuleFinder.of(system, dir1, dir2);
1885

1886
        Configuration cf = resolve(finder, "m1");
1887

1888
        assertTrue(cf.modules().size() == 3);
1889
        assertTrue(cf.findModule("java.base").isPresent());
1890
        assertTrue(cf.findModule("m1").isPresent());
1891
        assertTrue(cf.findModule("m2").isPresent());
1892
    }
1893

1894
    /**
1895
     * Test attempting to create a configuration with modules for different
1896
     * platforms.
1897
     */
1898
    @Test(dataProvider = "platformmismatch",
1899
          expectedExceptions = FindException.class )
1900
    public void testPlatformMisMatch(String s1, String s2) throws IOException {
1901
        testPlatformMatch(s1, s2);
1902
    }
1903

1904
    // no parents
1905

1906
    @Test(expectedExceptions = { IllegalArgumentException.class })
1907
    public void testResolveRequiresWithNoParents() {
1908
        ModuleFinder empty = ModuleFinder.of();
1909
        Configuration.resolve(empty, List.of(), empty, Set.of());
1910
    }
1911

1912
    @Test(expectedExceptions = { IllegalArgumentException.class })
1913
    public void testResolveRequiresAndUsesWithNoParents() {
1914
        ModuleFinder empty = ModuleFinder.of();
1915
        Configuration.resolveAndBind(empty, List.of(), empty, Set.of());
1916
    }
1917

1918

1919
    // parents with modules for specific platforms
1920
    @Test(dataProvider = "platformmatch")
1921
    public void testResolveRequiresWithCompatibleParents(String s1, String s2)
1922
        throws IOException
1923
    {
1924
        ModuleDescriptor base =  ModuleDescriptor.newModule("java.base").build();
1925
        Path system = writeModule(base, null);
1926

1927
        ModuleDescriptor descriptor1 = ModuleDescriptor.newModule("m1").build();
1928
        Path dir1 = writeModule(descriptor1, s1);
1929

1930
        ModuleDescriptor descriptor2 = ModuleDescriptor.newModule("m2").build();
1931
        Path dir2 = writeModule(descriptor2, s2);
1932

1933
        ModuleFinder finder1 = ModuleFinder.of(system, dir1);
1934
        Configuration cf1 = resolve(finder1, "m1");
1935

1936
        ModuleFinder finder2 = ModuleFinder.of(system, dir2);
1937
        Configuration cf2 = resolve(finder2, "m2");
1938

1939
        Configuration cf3 = Configuration.resolve(ModuleFinder.of(),
1940
                                                  List.of(cf1, cf2),
1941
                                                  ModuleFinder.of(),
1942
                                                  Set.of());
1943
        assertTrue(cf3.parents().size() == 2);
1944
    }
1945

1946

1947
    @Test(dataProvider = "platformmismatch",
1948
          expectedExceptions = IllegalArgumentException.class )
1949
    public void testResolveRequiresWithConflictingParents(String s1, String s2)
1950
        throws IOException
1951
    {
1952
        testResolveRequiresWithCompatibleParents(s1, s2);
1953
    }
1954

1955

1956
    // null handling
1957

1958
    // finder1, finder2, roots
1959

1960

1961
    @Test(expectedExceptions = { NullPointerException.class })
1962
    public void testResolveRequiresWithNull1() {
1963
        resolve((ModuleFinder)null, ModuleFinder.of());
1964
    }
1965

1966
    @Test(expectedExceptions = { NullPointerException.class })
1967
    public void testResolveRequiresWithNull2() {
1968
        resolve(ModuleFinder.of(), (ModuleFinder)null);
1969
    }
1970

1971
    @Test(expectedExceptions = { NullPointerException.class })
1972
    public void testResolveRequiresWithNull3() {
1973
        Configuration empty = Configuration.empty();
1974
        Configuration.resolve(null, List.of(empty),  ModuleFinder.of(), Set.of());
1975
    }
1976

1977
    @Test(expectedExceptions = { NullPointerException.class })
1978
    public void testResolveRequiresWithNull4() {
1979
        ModuleFinder empty = ModuleFinder.of();
1980
        Configuration.resolve(empty, null, empty, Set.of());
1981
    }
1982

1983
    @Test(expectedExceptions = { NullPointerException.class })
1984
    public void testResolveRequiresWithNull5() {
1985
        Configuration cf = ModuleLayer.boot().configuration();
1986
        Configuration.resolve(ModuleFinder.of(), List.of(cf), null, Set.of());
1987
    }
1988

1989
    @Test(expectedExceptions = { NullPointerException.class })
1990
    public void testResolveRequiresWithNull6() {
1991
        ModuleFinder empty = ModuleFinder.of();
1992
        Configuration cf = ModuleLayer.boot().configuration();
1993
        Configuration.resolve(empty, List.of(cf), empty, null);
1994
    }
1995

1996
    @Test(expectedExceptions = { NullPointerException.class })
1997
    public void testResolveRequiresAndUsesWithNull1() {
1998
        resolveAndBind((ModuleFinder) null, ModuleFinder.of());
1999
    }
2000

2001
    @Test(expectedExceptions = { NullPointerException.class })
2002
    public void testResolveRequiresAndUsesWithNull2() {
2003
        resolveAndBind(ModuleFinder.of(), (ModuleFinder) null);
2004
    }
2005

2006
    @Test(expectedExceptions = { NullPointerException.class })
2007
    public void testResolveRequiresAndUsesWithNull3() {
2008
        Configuration empty = Configuration.empty();
2009
        Configuration.resolveAndBind(null, List.of(empty), ModuleFinder.of(), Set.of());
2010
    }
2011

2012
    @Test(expectedExceptions = { NullPointerException.class })
2013
    public void testResolveRequiresAndUsesWithNull4() {
2014
        ModuleFinder empty = ModuleFinder.of();
2015
        Configuration.resolveAndBind(empty, null, empty, Set.of());
2016
    }
2017

2018
    @Test(expectedExceptions = { NullPointerException.class })
2019
    public void testResolveRequiresAndUsesWithNull5() {
2020
        Configuration cf = ModuleLayer.boot().configuration();
2021
        Configuration.resolveAndBind(ModuleFinder.of(), List.of(cf), null, Set.of());
2022
    }
2023

2024
    @Test(expectedExceptions = { NullPointerException.class })
2025
    public void testResolveRequiresAndUsesWithNull6() {
2026
        ModuleFinder empty = ModuleFinder.of();
2027
        Configuration cf = ModuleLayer.boot().configuration();
2028
        Configuration.resolveAndBind(empty, List.of(cf), empty, null);
2029
    }
2030

2031
    @Test(expectedExceptions = { NullPointerException.class })
2032
    public void testFindModuleWithNull() {
2033
        Configuration.empty().findModule(null);
2034
    }
2035

2036
    // unmodifiable collections
2037

2038
    @DataProvider(name = "configurations")
2039
    public Object[][] configurations() {
2040
        // empty, boot, and custom configurations
2041
        return new Object[][] {
2042
            { Configuration.empty(),              null },
2043
            { ModuleLayer.boot().configuration(), null },
2044
            { resolve(ModuleFinder.of()),         null },
2045
        };
2046
    }
2047

2048
    @Test(dataProvider = "configurations",
2049
            expectedExceptions = { UnsupportedOperationException.class })
2050
    public void testUnmodifiableParents1(Configuration cf, Object ignore) {
2051
        cf.parents().add(Configuration.empty());
2052
    }
2053

2054
    @Test(dataProvider = "configurations",
2055
            expectedExceptions = { UnsupportedOperationException.class })
2056
    public void testUnmodifiableParents2(Configuration cf, Object ignore) {
2057
        cf.parents().remove(Configuration.empty());
2058
    }
2059

2060
    @Test(dataProvider = "configurations",
2061
            expectedExceptions = { UnsupportedOperationException.class })
2062
    public void testUnmodifiableModules1(Configuration cf, Object ignore) {
2063
        ResolvedModule module = ModuleLayer.boot()
2064
                .configuration()
2065
                .findModule("java.base")
2066
                .orElseThrow();
2067
        cf.modules().add(module);
2068
    }
2069

2070
    @Test(dataProvider = "configurations",
2071
            expectedExceptions = { UnsupportedOperationException.class })
2072
    public void testUnmodifiableModules2(Configuration cf, Object ignore) {
2073
        ResolvedModule module = ModuleLayer.boot()
2074
                .configuration()
2075
                .findModule("java.base")
2076
                .orElseThrow();
2077
        cf.modules().remove(module);
2078
    }
2079

2080
    /**
2081
     * Invokes parent.resolve(...)
2082
     */
2083
    private Configuration resolve(Configuration parent,
2084
                                  ModuleFinder before,
2085
                                  ModuleFinder after,
2086
                                  String... roots) {
2087
        return parent.resolve(before, after, Set.of(roots));
2088
    }
2089

2090
    private Configuration resolve(Configuration parent,
2091
                                  ModuleFinder before,
2092
                                  String... roots) {
2093
        return resolve(parent, before, ModuleFinder.of(), roots);
2094
    }
2095

2096
    private Configuration resolve(ModuleFinder before,
2097
                                  ModuleFinder after,
2098
                                  String... roots) {
2099
        return resolve(Configuration.empty(), before, after, roots);
2100
    }
2101

2102
    private Configuration resolve(ModuleFinder before,
2103
                                  String... roots) {
2104
        return resolve(Configuration.empty(), before, roots);
2105
    }
2106

2107

2108
    /**
2109
     * Invokes parent.resolveAndBind(...)
2110
     */
2111
    private Configuration resolveAndBind(Configuration parent,
2112
                                         ModuleFinder before,
2113
                                         ModuleFinder after,
2114
                                         String... roots) {
2115
        return parent.resolveAndBind(before, after, Set.of(roots));
2116
    }
2117

2118
    private Configuration resolveAndBind(Configuration parent,
2119
                                         ModuleFinder before,
2120
                                         String... roots) {
2121
        return resolveAndBind(parent, before, ModuleFinder.of(), roots);
2122
    }
2123

2124
    private Configuration resolveAndBind(ModuleFinder before,
2125
                                         ModuleFinder after,
2126
                                         String... roots) {
2127
        return resolveAndBind(Configuration.empty(), before, after, roots);
2128
    }
2129

2130
    private Configuration resolveAndBind(ModuleFinder before,
2131
                                         String... roots) {
2132
        return resolveAndBind(Configuration.empty(), before, roots);
2133
    }
2134

2135

2136
    /**
2137
     * Writes a module-info.class. If {@code targetPlatform} is not null then
2138
     * it includes the ModuleTarget class file attribute with the target platform.
2139
     */
2140
    static Path writeModule(ModuleDescriptor descriptor, String targetPlatform)
2141
        throws IOException
2142
    {
2143
        ModuleTarget target;
2144
        if (targetPlatform != null) {
2145
            target = new ModuleTarget(targetPlatform);
2146
        } else {
2147
            target = null;
2148
        }
2149
        String name = descriptor.name();
2150
        Path dir = Files.createTempDirectory(Paths.get(""), name);
2151
        Path mi = dir.resolve("module-info.class");
2152
        try (OutputStream out = Files.newOutputStream(mi)) {
2153
            ModuleInfoWriter.write(descriptor, target, out);
2154
        }
2155
        return dir;
2156
    }
2157
}
2158

2159
Product

Resources

Company
