< prev index next >

test/java/lang/module/ModuleReferenceTest.java

Print this page




  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  * @run testng ModuleReferenceTest
  27  * @summary Basic tests for java.lang.module.ModuleReference
  28  */
  29 
  30 import java.lang.module.ModuleDescriptor;
  31 import java.lang.module.ModuleReader;
  32 import java.lang.module.ModuleReference;
  33 import java.net.URI;
  34 import java.util.function.Supplier;
  35 
  36 import org.testng.annotations.Test;
  37 import static org.testng.Assert.*;
  38 
  39 @Test
  40 public class ModuleReferenceTest {
  41 
  42     private Supplier<ModuleReader> makeSupplier() {
  43         return () -> { throw new UnsupportedOperationException(); };





  44     }
  45 
  46     public void testBasic() throws Exception {
  47         ModuleDescriptor descriptor
  48             = ModuleDescriptor.module("m")
  49                 .exports("p")
  50                 .exports("q")
  51                 .contains("p.internal")
  52                 .build();
  53 
  54         URI uri = URI.create("module:/m");
  55 
  56         Supplier<ModuleReader> supplier = makeSupplier();
  57 
  58         ModuleReference mref = new ModuleReference(descriptor, uri, supplier);
  59 
  60         assertTrue(mref.descriptor().equals(descriptor));
  61         assertTrue(mref.location().get().equals(uri));
  62 
  63         // check that the supplier is called
  64         try {
  65             mref.open();
  66             assertTrue(false);
  67         } catch (UnsupportedOperationException expected) { }
  68     }
  69 
  70 
  71     @Test(expectedExceptions = { NullPointerException.class })
  72     public void testNullDescriptor() throws Exception {
  73         URI location = URI.create("module:/m");
  74         new ModuleReference(null, location, makeSupplier());
  75     }
  76 
  77     public void testNullLocation() {
  78         ModuleDescriptor descriptor
  79             = ModuleDescriptor.module("m")
  80                 .exports("p")
  81                 .build();
  82         Supplier<ModuleReader> supplier = makeSupplier();
  83         ModuleReference mref = new ModuleReference(descriptor, null, supplier);
  84         assertTrue(!mref.location().isPresent());
  85     }
  86 
  87     @Test(expectedExceptions = { NullPointerException.class })
  88     public void testNullSupplier() throws Exception {
  89         ModuleDescriptor descriptor = ModuleDescriptor.module("m").build();
  90         URI location = URI.create("module:/m");
  91         new ModuleReference(descriptor, location, null);
  92     }
  93 
  94 
  95     public void testEqualsAndHashCode() {
  96         ModuleDescriptor descriptor1
  97             = ModuleDescriptor.module("m1")
  98                 .exports("p")
  99                 .build();
 100         ModuleDescriptor descriptor2
 101             = ModuleDescriptor.module("m1")
 102                 .exports("p")
 103                 .build();
 104 
 105         URI uri = URI.create("module:/m1");
 106         Supplier<ModuleReader> supplier = makeSupplier();
 107 
 108         ModuleReference mref1 = new ModuleReference(descriptor1, uri, supplier);
 109         ModuleReference mref2 = new ModuleReference(descriptor2, uri, supplier);
 110         ModuleReference mref3 = new ModuleReference(descriptor1, null, supplier);
 111 
 112         assertTrue(mref1.equals(mref1));
 113         assertTrue(mref1.equals(mref2));
 114         assertTrue(mref2.equals(mref1));
 115         assertTrue(mref1.hashCode() == mref2.hashCode());
 116 
 117         assertTrue(mref3.equals(mref3));
 118         assertFalse(mref3.equals(mref1));
 119         assertFalse(mref1.equals(mref3));
 120     }
 121 
 122 
 123     public void testToString() {
 124         ModuleDescriptor descriptor = ModuleDescriptor.module("m1").build();
 125         URI uri = URI.create("module:/m1");
 126         Supplier<ModuleReader> supplier = makeSupplier();
 127         ModuleReference mref = new ModuleReference(descriptor, uri, supplier);
 128         String s = mref.toString();
 129         assertTrue(s.contains("m1"));
 130         assertTrue(s.contains(uri.toString()));
 131     }
 132 
 133 }


  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  * @run testng ModuleReferenceTest
  27  * @summary Basic tests for java.lang.module.ModuleReference
  28  */
  29 
  30 import java.lang.module.ModuleDescriptor;
  31 import java.lang.module.ModuleReader;
  32 import java.lang.module.ModuleReference;
  33 import java.net.URI;

  34 
  35 import org.testng.annotations.Test;
  36 import static org.testng.Assert.*;
  37 
  38 @Test
  39 public class ModuleReferenceTest {
  40 
  41     private ModuleReference newModuleReference(ModuleDescriptor descriptor, URI uri) {
  42         return new ModuleReference(descriptor, uri) {
  43             @Override
  44             public ModuleReader open() {
  45                 throw new UnsupportedOperationException();
  46             }
  47         };
  48     }
  49 
  50     public void testBasic() throws Exception {
  51         ModuleDescriptor descriptor
  52             = ModuleDescriptor.module("m")
  53                 .exports("p")
  54                 .exports("q")
  55                 .contains("p.internal")
  56                 .build();
  57 
  58         URI uri = URI.create("module:/m");
  59 
  60         ModuleReference mref = newModuleReference(descriptor, uri);


  61 
  62         assertTrue(mref.descriptor().equals(descriptor));
  63         assertTrue(mref.location().get().equals(uri));






  64     }
  65 

  66     @Test(expectedExceptions = { NullPointerException.class })
  67     public void testNullDescriptor() throws Exception {
  68         URI location = URI.create("module:/m");
  69         newModuleReference(null, location);
  70     }
  71 
  72     public void testNullLocation() {
  73         ModuleDescriptor descriptor
  74             = ModuleDescriptor.module("m")
  75                 .exports("p")
  76                 .build();
  77         ModuleReference mref = newModuleReference(descriptor, null);

  78         assertTrue(!mref.location().isPresent());
  79     }
  80 














































  81 }
< prev index next >