View Javadoc

1   package org.apache.torque.generator.qname;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import static org.junit.Assert.assertEquals;
23  import static org.junit.Assert.assertFalse;
24  import static org.junit.Assert.fail;
25  
26  import java.util.ArrayList;
27  import java.util.List;
28  
29  import org.apache.torque.generator.qname.Namespace;
30  import org.apache.torque.generator.qname.QualifiedName;
31  import org.junit.Test;
32  
33  public class QualifiedNameTest
34  {
35      @Test
36      public void testConstructors()
37      {
38          QualifiedName qualifiedName
39                  = new QualifiedName("org.apache.torque.name");
40          assertEquals("name", qualifiedName.getName());
41          assertEquals(
42                  new Namespace("org.apache.torque"),
43                  qualifiedName.getNamespace());
44  
45          qualifiedName = new QualifiedName("name");
46          assertEquals("name", qualifiedName.getName());
47          assertEquals(Namespace.ROOT_NAMESPACE, qualifiedName.getNamespace());
48  
49          qualifiedName = new QualifiedName(".name");
50          assertEquals("name", qualifiedName.getName());
51          assertEquals(Namespace.ROOT_NAMESPACE, qualifiedName.getNamespace());
52  
53          qualifiedName
54                  = new QualifiedName("name", new Namespace("org.apache.torque"));
55          assertEquals("name", qualifiedName.getName());
56          assertEquals(
57                  new Namespace("org.apache.torque"),
58                  qualifiedName.getNamespace());
59  
60          qualifiedName = new QualifiedName("name", (Namespace) null);
61          assertEquals("name", qualifiedName.getName());
62          assertEquals(Namespace.ROOT_NAMESPACE, qualifiedName.getNamespace());
63  
64          qualifiedName = new QualifiedName("name", new Namespace(""));
65          assertEquals("name", qualifiedName.getName());
66          assertEquals(Namespace.ROOT_NAMESPACE, qualifiedName.getNamespace());
67      }
68  
69      @Test
70      public void testEmptyNames()
71      {
72          try
73          {
74              new QualifiedName("org.apache.torque.");
75              fail("Could generate QualifiedName from String "
76                      + "with empty name part");
77          }
78          catch (IllegalArgumentException e)
79          {
80          }
81  
82          try
83          {
84              new QualifiedName("", "org.apache.torque");
85              fail("Could generate QualifiedName with empty name");
86          }
87          catch (IllegalArgumentException e)
88          {
89          }
90      }
91  
92      @Test
93      public void testNamespaceFromParts()
94      {
95          List<String> parts = new ArrayList<String>(3);
96          parts.add("org");
97          parts.add("apache");
98          parts.add("torque");
99          Namespace namespace = new Namespace(parts);
100         assertEquals(namespace, new Namespace("org.apache.torque"));
101 
102         parts = new ArrayList<String>();
103         namespace = new Namespace(parts);
104         assertEquals(Namespace.ROOT_NAMESPACE, namespace);
105 
106         parts = null;
107         try
108         {
109             namespace = new Namespace(parts);
110             fail("should not be able to construct namespace "
111                     + "from null list");
112         }
113         catch (NullPointerException e)
114         {
115         }
116     }
117 
118     @Test
119     public void testGetNamespaceParts()
120     {
121         QualifiedName qualifiedName
122                 = new QualifiedName("org.apache.torque.name");
123         List<String> parts = qualifiedName.getNamespace().getParts();
124         assertEquals(parts.size(), 3);
125         assertEquals(parts.get(0), "org");
126         assertEquals(parts.get(1), "apache");
127         assertEquals(parts.get(2), "torque");
128     }
129 
130     @Test
131     public void testGetParentNamespace()
132     {
133         QualifiedName qualifiedName
134                 = new QualifiedName("org.apache.torque.name");
135         Namespace parentNamespace = qualifiedName.getParentNamespace();
136         assertEquals(parentNamespace, new Namespace("org.apache"));
137 
138         qualifiedName = new QualifiedName("org.name");
139         parentNamespace = qualifiedName.getParentNamespace();
140         assertEquals(Namespace.ROOT_NAMESPACE, parentNamespace);
141 
142         qualifiedName = new QualifiedName(".name");
143         parentNamespace = qualifiedName.getParentNamespace();
144         assertEquals(Namespace.ROOT_NAMESPACE, parentNamespace);
145     }
146 
147     @Test
148     public void testEquals()
149     {
150         QualifiedName qualifiedName
151                 = new QualifiedName("org.apache.torque.name");
152         assertEquals(
153                 qualifiedName,
154                 new QualifiedName("org.apache.torque.name"));
155         assertFalse(
156                 qualifiedName.equals(
157                         new QualifiedName("org.apache.name")));
158         assertFalse(
159                 qualifiedName.equals(
160                         new QualifiedName(".name")));
161         assertFalse(
162                 qualifiedName.equals(
163                         new QualifiedName("org.apache.torque.otherName")));
164 
165         qualifiedName = new QualifiedName(".name");
166         assertEquals(
167                 qualifiedName,
168                 new QualifiedName(".name"));
169         assertEquals(
170                 qualifiedName,
171                 new QualifiedName("name"));
172         assertFalse(
173                 qualifiedName.equals(
174                         new QualifiedName("org.apache.name")));
175         assertFalse(
176                 qualifiedName.equals(
177                         new QualifiedName(".otherName")));
178     }
179 }