View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  
20  package org.apache.myfaces.tobago.context;
21  
22  import org.junit.jupiter.api.Assertions;
23  import org.junit.jupiter.api.Test;
24  
25  import java.lang.reflect.Field;
26  import java.util.ArrayList;
27  import java.util.Arrays;
28  import java.util.Iterator;
29  import java.util.List;
30  
31  public class MarkupUnitTest {
32  
33    private static final String[] AB = new String[]{"a", "b"};
34  
35    @Test
36    public void testString() {
37      Assertions.assertNull(Markup.valueOf((String) null));
38  
39      Assertions.assertEquals("foobar", Markup.valueOf("foo$bar").toString());
40  
41      Assertions.assertEquals("fooBar", Markup.valueOf("fooBar").toString());
42  
43      Assertions.assertArrayEquals(new String[]{"accent"}, toArray(Markup.valueOf("accent").iterator()));
44  
45      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf("a,b").iterator()));
46  
47      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf("a, b").iterator()));
48  
49      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf("a b").iterator()));
50  
51      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf(", \ta , ,\n b ,").iterator()));
52  
53      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf(", \ta\" , ,\n b ,").iterator()));
54    }
55  
56    @Test
57    public void testStringArray() {
58      Assertions.assertNull(Markup.valueOf((String[]) null));
59  
60      Assertions.assertNull(Markup.valueOf(new String[]{}));
61  
62      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf(new String[]{"a", "b"}).iterator()));
63  
64      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf(new String[]{" a ", " b "}).iterator()));
65    }
66  
67    @Test
68    public void testObject() {
69      Assertions.assertNull(Markup.valueOf((Object) null));
70  
71      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf((Object) ", \ta , ,\n b ,").iterator()));
72  
73      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf((Object) new String[]{"a", "b"}).iterator()));
74  
75      Assertions.assertArrayEquals(AB,
76          toArray(Markup.valueOf((Object) new String[]{" a ", " b "}).iterator()));
77  
78      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf(new StringBuilder("a, b")).iterator()));
79  
80      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf(AB).iterator()));
81  
82      Assertions.assertArrayEquals(AB, toArray(Markup.valueOf(Arrays.asList(AB)).iterator()));
83    }
84  
85    @Test
86    public void testMarkup() {
87      Assertions.assertNull(Markup.valueOf((Markup) null));
88  
89      final Markup accent = Markup.valueOf("accent");
90      Assertions.assertSame(accent, Markup.valueOf(accent));
91    }
92  
93    @Test
94    public void testAdd() {
95      final Markup a = Markup.valueOf("a");
96      final Markup b = Markup.valueOf("b");
97      final Markup c = Markup.valueOf("c");
98      final Markup ab = Markup.valueOf("a,b");
99      final Markup abc = Markup.valueOf("a,b,c");
100     Assertions.assertEquals(a, Markup.NULL.add(a));
101     Assertions.assertEquals(ab, a.add(b));
102     Assertions.assertEquals(abc, ab.add(c));
103     Assertions.assertEquals(abc, ab.add(abc));
104     Assertions.assertSame(a, a.add(a));
105     Assertions.assertSame(ab, ab.add(a));
106     Assertions.assertSame(ab, ab.add(ab));
107   }
108 
109   @Test
110   public void testRemove() {
111     final Markup a = Markup.valueOf("a");
112     final Markup b = Markup.valueOf("b");
113     final Markup c = Markup.valueOf("c");
114     final Markup ab = Markup.valueOf("a,b");
115     final Markup bc = Markup.valueOf("b,c");
116     final Markup abc = Markup.valueOf("a,b,c");
117     Assertions.assertEquals(Markup.NULL, Markup.NULL.remove(a));
118     Assertions.assertEquals(a, a.remove(b));
119     Assertions.assertEquals(Markup.NULL, a.remove(a));
120     Assertions.assertEquals(b, ab.remove(a));
121     Assertions.assertEquals(a, ab.remove(b));
122     Assertions.assertEquals(c, abc.remove(ab));
123     Assertions.assertEquals(a, ab.remove(bc));
124     Assertions.assertEquals(Markup.NULL, abc.remove(abc));
125     Assertions.assertSame(b, b.remove(a));
126     Assertions.assertSame(ab, ab.remove(c));
127   }
128 
129   @Test
130   public void testContainsString() {
131     final Markup a = Markup.valueOf("a");
132     final Markup ab = Markup.valueOf("a,b");
133     Assertions.assertFalse(Markup.NULL.contains("a"));
134     Assertions.assertTrue(a.contains("a"));
135     Assertions.assertTrue(a.contains((String) null));
136     Assertions.assertFalse(a.contains("b"));
137     Assertions.assertTrue(ab.contains("a"));
138     Assertions.assertTrue(ab.contains("b"));
139     Assertions.assertFalse(ab.contains("c"));
140   }
141 
142   @Test
143   public void testContainsMarkup() {
144     final Markup a = Markup.valueOf("a");
145     final Markup ab = Markup.valueOf("a,b");
146     Assertions.assertFalse(Markup.NULL.contains(Markup.valueOf("a")));
147     Assertions.assertTrue(a.contains(Markup.NULL));
148     Assertions.assertTrue(a.contains((Markup) null));
149     Assertions.assertTrue(a.contains(Markup.valueOf("a")));
150     Assertions.assertFalse(a.contains(Markup.valueOf("b")));
151     Assertions.assertTrue(ab.contains(Markup.valueOf("a")));
152     Assertions.assertTrue(ab.contains(Markup.valueOf("b")));
153     Assertions.assertFalse(ab.contains(Markup.valueOf("c")));
154     Assertions.assertTrue(ab.contains(Markup.valueOf("a,b")));
155     Assertions.assertTrue(ab.contains(Markup.valueOf("a,a")));
156     Assertions.assertFalse(ab.contains(Markup.valueOf("a,c")));
157     Assertions.assertFalse(ab.contains(Markup.valueOf("a,c,d,e,c,f,e,f")));
158   }
159 
160   @Test
161   public void testIsEmpty() {
162     final Markup a = Markup.valueOf("a");
163     final Markup ab = Markup.valueOf("a,b");
164 
165     Assertions.assertFalse(a.isEmpty());
166     Assertions.assertFalse(ab.isEmpty());
167     Assertions.assertTrue(Markup.NULL.isEmpty());
168   }
169 
170   public static Object[] toArray(final Iterator<?> iterator) {
171     final List<Object> list = new ArrayList<Object>(10);
172     while (iterator.hasNext()) {
173       list.add(iterator.next());
174     }
175     return list.toArray();
176   }
177 
178   @Test
179   public void testNames() throws IllegalAccessException {
180     final List<Field> markups = new ArrayList<>();
181     final List<Field> strings = new ArrayList<>();
182 
183     for (final Field field : Markup.class.getFields()) {
184       if (field.getName().startsWith("STRING")) {
185         strings.add(field);
186       } else if (!field.getName().equals("NULL")) {
187         markups.add(field);
188       }
189     }
190 
191     Assertions.assertEquals(markups.size(), strings.size(), "Is for every markup a string constant defined?");
192 
193     for (final Field markupField : markups) {
194       final Markup markup = (Markup) markupField.get(null);
195 
196       boolean pendantFound = false;
197       for (final Field stringField : strings) {
198         if (stringField.getName().equals("STRING_" + markupField.getName())) {
199           final String string = (String) stringField.get(null);
200 
201           Assertions.assertEquals(markup.toString(), string);
202           pendantFound = true;
203         }
204       }
205 
206       Assertions.assertTrue(pendantFound, "Could be a string pendant found for " + markup + "?");
207     }
208   }
209 }