View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.io;
18  
19  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
20  import static org.junit.jupiter.api.Assertions.assertEquals;
21  import static org.junit.jupiter.api.Assertions.assertFalse;
22  import static org.junit.jupiter.api.Assertions.assertNotEquals;
23  import static org.junit.jupiter.api.Assertions.assertNotNull;
24  import static org.junit.jupiter.api.Assertions.assertThrows;
25  import static org.junit.jupiter.api.Assertions.assertTrue;
26  
27  import java.nio.charset.Charset;
28  
29  import org.junit.jupiter.api.Test;
30  
31  /**
32   * Test for {@link ByteOrderMark}.
33   */
34  class ByteOrderMarkTest {
35  
36      private static final ByteOrderMark TEST_BOM_1 = new ByteOrderMark("test1", 1);
37      private static final ByteOrderMark TEST_BOM_2 = new ByteOrderMark("test2", 1, 2);
38      private static final ByteOrderMark TEST_BOM_3 = new ByteOrderMark("test3", 1, 2, 3);
39  
40      /** Tests that {@link ByteOrderMark#getCharsetName()} can be loaded as a {@link java.nio.charset.Charset} as advertised. */
41      @Test
42      void testConstantCharsetNames() {
43          assertNotNull(Charset.forName(ByteOrderMark.UTF_8.getCharsetName()));
44          assertNotNull(Charset.forName(ByteOrderMark.UTF_16BE.getCharsetName()));
45          assertNotNull(Charset.forName(ByteOrderMark.UTF_16LE.getCharsetName()));
46          assertNotNull(Charset.forName(ByteOrderMark.UTF_32BE.getCharsetName()));
47          assertNotNull(Charset.forName(ByteOrderMark.UTF_32LE.getCharsetName()));
48      }
49  
50      /** Tests Exceptions */
51      @Test
52      void testConstructorExceptions() {
53          assertThrows(NullPointerException.class, () -> new ByteOrderMark(null, 1, 2, 3));
54          assertThrows(IllegalArgumentException.class, () -> new ByteOrderMark("", 1, 2, 3));
55          assertThrows(NullPointerException.class, () -> new ByteOrderMark("a", (int[]) null));
56          assertThrows(IllegalArgumentException.class, () -> new ByteOrderMark("b"));
57      }
58  
59      /** Tests {@link ByteOrderMark#equals(Object)} */
60      @SuppressWarnings("EqualsWithItself")
61      @Test
62      void testEquals() {
63          assertEquals(ByteOrderMark.UTF_16BE, ByteOrderMark.UTF_16BE);
64          assertEquals(ByteOrderMark.UTF_16LE, ByteOrderMark.UTF_16LE);
65          assertEquals(ByteOrderMark.UTF_32BE, ByteOrderMark.UTF_32BE);
66          assertEquals(ByteOrderMark.UTF_32LE, ByteOrderMark.UTF_32LE);
67          assertEquals(ByteOrderMark.UTF_8, ByteOrderMark.UTF_8);
68  
69          assertNotEquals(ByteOrderMark.UTF_8, ByteOrderMark.UTF_16BE);
70          assertNotEquals(ByteOrderMark.UTF_8, ByteOrderMark.UTF_16LE);
71          assertNotEquals(ByteOrderMark.UTF_8, ByteOrderMark.UTF_32BE);
72          assertNotEquals(ByteOrderMark.UTF_8, ByteOrderMark.UTF_32LE);
73  
74          assertEquals(TEST_BOM_1, TEST_BOM_1, "test1 equals");
75          assertEquals(TEST_BOM_2, TEST_BOM_2, "test2 equals");
76          assertEquals(TEST_BOM_3, TEST_BOM_3, "test3 equals");
77  
78          assertNotEquals(TEST_BOM_1, new Object(), "Object not equal");
79          assertNotEquals(TEST_BOM_1, new ByteOrderMark("1a", 2), "test1-1 not equal");
80          assertNotEquals(TEST_BOM_1, new ByteOrderMark("1b", 1, 2), "test1-2 not test2");
81          assertNotEquals(TEST_BOM_2, new ByteOrderMark("2", 1, 1), "test2 not equal");
82          assertNotEquals(TEST_BOM_3, new ByteOrderMark("3", 1, 2, 4), "test3 not equal");
83      }
84  
85      /** Tests {@link ByteOrderMark#getBytes()} */
86      @Test
87      void testGetBytes() {
88          assertArrayEquals(TEST_BOM_1.getBytes(), new byte[] { (byte) 1 }, "test1 bytes");
89          TEST_BOM_1.getBytes()[0] = 2;
90          assertArrayEquals(TEST_BOM_1.getBytes(), new byte[] { (byte) 1 }, "test1 bytes");
91          assertArrayEquals(TEST_BOM_2.getBytes(), new byte[] { (byte) 1, (byte) 2 }, "test1 bytes");
92          assertArrayEquals(TEST_BOM_3.getBytes(), new byte[] { (byte) 1, (byte) 2, (byte) 3 }, "test1 bytes");
93      }
94  
95      /** Tests {@link ByteOrderMark#getCharsetName()} */
96      @Test
97      void testGetCharsetName() {
98          assertEquals("test1", TEST_BOM_1.getCharsetName(), "test1 name");
99          assertEquals("test2", TEST_BOM_2.getCharsetName(), "test2 name");
100         assertEquals("test3", TEST_BOM_3.getCharsetName(), "test3 name");
101     }
102 
103     /** Tests {@link ByteOrderMark#get(int)} */
104     @Test
105     void testGetInt() {
106         assertEquals(1, TEST_BOM_1.get(0), "test1 get(0)");
107         assertEquals(1, TEST_BOM_2.get(0), "test2 get(0)");
108         assertEquals(2, TEST_BOM_2.get(1), "test2 get(1)");
109         assertEquals(1, TEST_BOM_3.get(0), "test3 get(0)");
110         assertEquals(2, TEST_BOM_3.get(1), "test3 get(1)");
111         assertEquals(3, TEST_BOM_3.get(2), "test3 get(2)");
112     }
113 
114     /** Tests {@link ByteOrderMark#hashCode()} */
115     @Test
116     void testHashCode() {
117         final int bomClassHash = ByteOrderMark.class.hashCode();
118         assertEquals(bomClassHash + 1, TEST_BOM_1.hashCode(), "hash test1 ");
119         assertEquals(bomClassHash + 3, TEST_BOM_2.hashCode(), "hash test2 ");
120         assertEquals(bomClassHash + 6, TEST_BOM_3.hashCode(), "hash test3 ");
121     }
122 
123     /** Tests {@link ByteOrderMark#length()} */
124     @Test
125     void testLength() {
126         assertEquals(1, TEST_BOM_1.length(), "test1 length");
127         assertEquals(2, TEST_BOM_2.length(), "test2 length");
128         assertEquals(3, TEST_BOM_3.length(), "test3 length");
129     }
130 
131     @Test
132     void testMatches() {
133         assertTrue(ByteOrderMark.UTF_16BE.matches(ByteOrderMark.UTF_16BE.getRawBytes()));
134         assertTrue(ByteOrderMark.UTF_16LE.matches(ByteOrderMark.UTF_16LE.getRawBytes()));
135         assertTrue(ByteOrderMark.UTF_32BE.matches(ByteOrderMark.UTF_32BE.getRawBytes()));
136         assertTrue(ByteOrderMark.UTF_16BE.matches(ByteOrderMark.UTF_16BE.getRawBytes()));
137         assertTrue(ByteOrderMark.UTF_8.matches(ByteOrderMark.UTF_8.getRawBytes()));
138 
139         assertTrue(TEST_BOM_1.matches(TEST_BOM_1.getRawBytes()));
140         assertTrue(TEST_BOM_2.matches(TEST_BOM_2.getRawBytes()));
141         assertTrue(TEST_BOM_3.matches(TEST_BOM_3.getRawBytes()));
142 
143         assertFalse(TEST_BOM_1.matches(new ByteOrderMark("1a", 2).getRawBytes()));
144         assertTrue(TEST_BOM_1.matches(new ByteOrderMark("1b", 1, 2).getRawBytes()));
145         assertFalse(TEST_BOM_2.matches(new ByteOrderMark("2", 1, 1).getRawBytes()));
146         assertFalse(TEST_BOM_3.matches(new ByteOrderMark("3", 1, 2, 4).getRawBytes()));
147     }
148 
149     /** Tests {@link ByteOrderMark#toString()} */
150     @Test
151     void testToString() {
152         assertEquals("ByteOrderMark[test1: 0x1]", TEST_BOM_1.toString(), "test1 ");
153         assertEquals("ByteOrderMark[test2: 0x1,0x2]", TEST_BOM_2.toString(), "test2 ");
154         assertEquals("ByteOrderMark[test3: 0x1,0x2,0x3]", TEST_BOM_3.toString(), "test3 ");
155     }
156 }