binding/binding-model-api/src/test/java/org/opendaylight/mdsal/binding/model/api/JavaTypeNameTest.java

   1 /*
   2  * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.model.api;
   9
  10 import static com.google.common.collect.ImmutableList.of;
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertSame;
  14 import static org.junit.Assert.assertTrue;
  15
  16 import java.util.Optional;
  17 import org.junit.Test;
  18
  19 public class JavaTypeNameTest {
  20
  21     @Test
  22     public void testOperations() {
  23         final JavaTypeName byteName = JavaTypeName.create(byte.class);
  24         assertEquals("", byteName.packageName());
  25         assertEquals("byte", byteName.simpleName());
  26         assertEquals("byte", byteName.toString());
  27         assertEquals(Optional.empty(), byteName.immediatelyEnclosingClass());
  28         assertSame(byteName, byteName.topLevelClass());
  29         assertEquals(of("byte"), byteName.localNameComponents());
  30         assertEquals("byte", byteName.localName());
  31
  32         final JavaTypeName charName = byteName.createSibling("char");
  33         assertEquals("", charName.packageName());
  34         assertEquals("char", charName.simpleName());
  35         assertEquals("char", charName.toString());
  36         assertEquals(Optional.empty(), charName.immediatelyEnclosingClass());
  37         assertSame(charName, charName.topLevelClass());
  38         assertEquals(of("char"), charName.localNameComponents());
  39         assertEquals("char", charName.localName());
  40
  41         final JavaTypeName threadName = JavaTypeName.create(Thread.class);
  42         assertEquals("java.lang", threadName.packageName());
  43         assertEquals("Thread", threadName.simpleName());
  44         assertEquals("java.lang.Thread", threadName.toString());
  45         assertEquals(Optional.empty(), threadName.immediatelyEnclosingClass());
  46         assertTrue(threadName.canCreateEnclosed("Foo"));
  47         assertFalse(threadName.canCreateEnclosed("Thread"));
  48         assertEquals(threadName, JavaTypeName.create("java.lang", "Thread"));
  49         assertSame(threadName, threadName.topLevelClass());
  50         assertEquals(of("Thread"), threadName.localNameComponents());
  51         assertEquals("Thread", threadName.localName());
  52
  53         final JavaTypeName stringName = threadName.createSibling("String");
  54         assertEquals("java.lang", stringName.packageName());
  55         assertEquals("String", stringName.simpleName());
  56         assertEquals("java.lang.String", stringName.toString());
  57         assertEquals(Optional.empty(), stringName.immediatelyEnclosingClass());
  58         assertEquals(stringName, JavaTypeName.create("java.lang", "String"));
  59
  60         final JavaTypeName enclosedName = threadName.createEnclosed("Foo");
  61         assertEquals("java.lang", enclosedName.packageName());
  62         assertEquals("Foo", enclosedName.simpleName());
  63         assertEquals("java.lang.Thread.Foo", enclosedName.toString());
  64         assertEquals(Optional.of(threadName), enclosedName.immediatelyEnclosingClass());
  65         assertSame(threadName, enclosedName.topLevelClass());
  66         assertEquals(of("Thread", "Foo"), enclosedName.localNameComponents());
  67         assertEquals("Thread.Foo", enclosedName.localName());
  68
  69         final JavaTypeName uehName = JavaTypeName.create(Thread.UncaughtExceptionHandler.class);
  70         assertEquals("java.lang", uehName.packageName());
  71         assertEquals("UncaughtExceptionHandler", uehName.simpleName());
  72         assertEquals("java.lang.Thread.UncaughtExceptionHandler", uehName.toString());
  73         assertEquals(Optional.of(threadName), uehName.immediatelyEnclosingClass());
  74         assertTrue(uehName.canCreateEnclosed("Foo"));
  75         assertFalse(uehName.canCreateEnclosed("Thread"));
  76         assertFalse(uehName.canCreateEnclosed("UncaughtExceptionHandler"));
  77
  78         final JavaTypeName siblingName = uehName.createSibling("Foo");
  79         assertEquals("java.lang", siblingName.packageName());
  80         assertEquals("Foo", siblingName.simpleName());
  81         assertEquals("java.lang.Thread.Foo", siblingName.toString());
  82         assertEquals(Optional.of(threadName), siblingName.immediatelyEnclosingClass());
  83         assertTrue(siblingName.canCreateEnclosed("UncaughtExceptionHandler"));
  84         assertFalse(siblingName.canCreateEnclosed("Thread"));
  85         assertFalse(siblingName.canCreateEnclosed("Foo"));
  86
  87         assertTrue(threadName.equals(JavaTypeName.create(Thread.class)));
  88         assertTrue(threadName.equals(threadName));
  89         assertFalse(threadName.equals(null));
  90         assertFalse(threadName.equals("foo"));
  91     }
  92
  93     @Test(expected = IllegalArgumentException.class)
  94     public void testCreateEmptyPackage() {
  95         JavaTypeName.create("", "Foo");
  96     }
  97
  98     @Test(expected = IllegalArgumentException.class)
  99     public void testCreateEmptyName() {
 100         JavaTypeName.create("foo", "");
 101     }
 102
 103     @Test(expected = UnsupportedOperationException.class)
 104     public void testCanCreateEnclosedPrimitive() {
 105         JavaTypeName.create(byte.class).canCreateEnclosed("foo");
 106     }
 107
 108     @Test(expected = UnsupportedOperationException.class)
 109     public void testCreateEnclosedPrimitive() {
 110         JavaTypeName.create(byte.class).createEnclosed("foo");
 111     }
 112 }