1  package dev.mohterbaord.chariki;
  2  
  3  import dev.mohterbaord.chariki.core.AbstractCharik;
  4  import org.apache.commons.lang3.ArrayUtils;
  5  import org.junit.jupiter.api.DisplayName;
  6  import org.junit.jupiter.api.MethodOrderer;
  7  import org.junit.jupiter.api.Test;
  8  import org.junit.jupiter.api.TestMethodOrder;
  9  
 10  import java.nio.charset.Charset;
 11  import java.util.NoSuchElementException;
 12  
 13  import static java.nio.charset.StandardCharsets.ISO_8859_1;
 14  import static java.nio.charset.StandardCharsets.UTF_8;
 15  import static org.junit.jupiter.api.Assertions.*;
 16  
 17  @DisplayName("AbstractCharik specs")
 18  @TestMethodOrder(MethodOrderer.DisplayName.class)
 19  public class AbstractCharikTest {
 20  
 21    // Charik methods
 22  
 23    @Test
 24    @DisplayName("#bytes")
 25    void spec_bytes() {
 26      var bytes = new byte[]{
 27        (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
 28      };
 29      var charik = charik(bytes);
 30      assertAll(
 31        () -> assertArrayEquals(bytes, charik.bytes()),
 32        () -> assertNotSame(bytes, charik.bytes())
 33      );
 34    }
 35  
 36    @Test
 37    @DisplayName("#charset")
 38    void spec_charset() {
 39      var charik = new AbstractCharik(null, UTF_8) {
 40      };
 41      assertEquals(UTF_8, charik.charset());
 42    }
 43  
 44    // Sizable methods
 45  
 46    @Test
 47    @DisplayName("#size")
 48    void spec_size() {
 49      assertAll(
 50        () -> {
 51          var bytes = new byte[]{
 52            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
 53          };
 54          assertEquals(4, charik(bytes).size());
 55        },
 56        () -> assertEquals(0, emptyCharik().size()),
 57        () -> assertThrows(NullPointerException.class, () -> nullCharik().size())
 58      );
 59    }
 60  
 61    // HexRepresentable methods
 62  
 63    @Test
 64    @DisplayName("#toHexString")
 65    void spec_toHexString() {
 66      assertAll(
 67        () -> {
 68          var bytes = new byte[]{
 69            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
 70          };
 71          assertEquals("f0 9f 8d bb", charik(bytes).toHexString());
 72        },
 73        () -> assertTrue(emptyCharik().toHexString().isEmpty()),
 74        () -> assertThrows(
 75          NullPointerException.class,
 76          () -> nullCharik().toHexString()
 77        )
 78      );
 79    }
 80  
 81    // Streamable<Byte> methods
 82  
 83    @Test
 84    @DisplayName("#stream")
 85    void spec_stream() {
 86      assertAll(
 87        () -> {
 88          var bytes = new byte[]{
 89            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
 90          };
 91          assertArrayEquals(
 92            bytes,
 93            ArrayUtils.toPrimitive(
 94              charik(bytes).stream()
 95                .toArray(Byte[]::new)
 96            )
 97          );
 98        },
 99        () -> assertArrayEquals(
100          new byte[0],
101          ArrayUtils.toPrimitive(
102            emptyCharik().stream()
103              .toArray(Byte[]::new)
104          )
105        ),
106        () -> {
107          var oneByteArr = new byte[]{ (byte) 0x41 };
108          assertArrayEquals(
109            oneByteArr,
110            ArrayUtils.toPrimitive(
111              charik(oneByteArr).stream()
112                .toArray(Byte[]::new)
113            )
114          );
115        },
116        () -> assertThrows(
117          NullPointerException.class,
118          () -> nullCharik().stream()
119        )
120      );
121    }
122  
123    // Iterable<Byte> methods
124  
125    @Test
126    @DisplayName("#iterator")
127    void spec_iterator() {
128      assertAll(
129        () -> {
130          var bytes = new byte[]{
131            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
132          };
133          var it = charik(bytes).iterator();
134          assertTrue(it.hasNext());
135          assertEquals((byte) 0xf0, it.next());
136          assertTrue(it.hasNext());
137          assertEquals((byte) 0x9f, it.next());
138          assertTrue(it.hasNext());
139          assertEquals((byte) 0x8d, it.next());
140          assertTrue(it.hasNext());
141          assertEquals((byte) 0xbb, it.next());
142          assertFalse(it.hasNext());
143          assertThrows(NoSuchElementException.class, it::next);
144        },
145        () -> {
146          var it = emptyCharik().iterator();
147          assertFalse(it.hasNext());
148          assertThrows(NoSuchElementException.class, it::next);
149        },
150        () -> assertThrows(
151          NullPointerException.class,
152          () -> nullCharik().iterator()
153        )
154      );
155    }
156  
157    @Test
158    @DisplayName("#spliterator")
159    void spec_spliterator() {
160      var bytes = new byte[]{
161        (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
162      };
163      var sp = charik(bytes).spliterator();
164      assertEquals(4, sp.getExactSizeIfKnown());
165    }
166  
167    // Object methods
168  
169    @Test
170    @DisplayName("#toString")
171    void spec_toString() {
172      assertAll(
173        () -> {
174          var bytes = new byte[]{
175            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
176          };
177          assertEquals("\ud83c\udf7b", new AbstractCharik(bytes, UTF_8) {
178          }.toString());
179        },
180        () -> assertEquals("", new AbstractCharik(new byte[0], UTF_8) {
181        }.toString()),
182        () -> assertThrows(
183          NullPointerException.class,
184          () -> new AbstractCharik(null, UTF_8) {
185          }.toString()
186        ),
187        () -> {
188          var bytes = new byte[]{
189            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
190          };
191          assertThrows(
192            NullPointerException.class,
193            () -> new AbstractCharik(bytes, null) {
194            }.toString()
195          );
196        }
197      );
198    }
199  
200    @Test
201    @DisplayName("#equals")
202    void spec_equals() {
203      assertAll(
204        () -> {
205          var bytes1 = new byte[]{
206            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
207          };
208          AbstractCharik charik1 = new AbstractCharik(bytes1, UTF_8) {
209          };
210          var bytes2 = new byte[]{
211            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
212          };
213          AbstractCharik charik2 = new AbstractCharik(bytes2, UTF_8) {
214          };
215          assertEquals(charik1, charik2);
216        },
217        () -> {
218          var bytes1 = new byte[]{
219            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
220          };
221          AbstractCharik charik1 = new AbstractCharik(bytes1, UTF_8) {
222          };
223          var bytes2 = new byte[]{
224            (byte) 0xf0, (byte) 0x9f, (byte) 0x8e, (byte) 0xb7
225          };
226          AbstractCharik charik2 = new AbstractCharik(bytes2, UTF_8) {
227          };
228          assertNotEquals(charik1, charik2);
229        },
230        () -> {
231          var bytes = new byte[]{
232            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
233          };
234          AbstractCharik charik1 = new AbstractCharik(bytes, UTF_8) {
235          };
236          AbstractCharik charik2 = new AbstractCharik(bytes, ISO_8859_1) {
237          };
238          assertNotEquals(charik1, charik2);
239        },
240        () -> {
241          var bytes = new byte[]{
242            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
243          };
244          var charik = new AbstractCharik(bytes, UTF_8) {
245          };
246          assertEquals(charik, charik);
247        },
248        () -> {
249          var bytes = new byte[]{
250            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
251          };
252          var charik = new AbstractCharik(bytes, UTF_8) {
253          };
254          assertFalse(charik.equals(null));
255        },
256        () -> {
257          var bytes = new byte[]{
258            (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
259          };
260          var charik = new AbstractCharik(bytes, UTF_8) {
261          };
262          assertFalse(charik.equals("not Charik"));
263        }
264      );
265    }
266  
267    @Test
268    @DisplayName("#hashCode")
269    void spec_hashCode() {
270      var bytes = new byte[]{
271        (byte) 0xf0, (byte) 0x9f, (byte) 0x8d, (byte) 0xbb
272      };
273      AbstractCharik charik1 = new AbstractCharik(bytes, UTF_8) {
274      };
275      AbstractCharik charik2 = new AbstractCharik(bytes, UTF_8) {
276      };
277      assertEquals(charik1.hashCode(), charik2.hashCode());
278    }
279  
280    // helpers
281  
282    private AbstractCharik charik(byte[] bytes) {
283      return new AbstractCharik(bytes, null) {
284        @Override
285        public Charset charset() {
286          throw new UnsupportedOperationException();
287        }
288      };
289    }
290  
291    private AbstractCharik emptyCharik() {
292      return new AbstractCharik(new byte[0], null) {
293        @Override
294        public Charset charset() {
295          throw new UnsupportedOperationException();
296        }
297      };
298    }
299  
300    private AbstractCharik nullCharik() {
301      return new AbstractCharik(null, null) {
302        @Override
303        public Charset charset() {
304          throw new UnsupportedOperationException();
305        }
306      };
307    }
308  
309  }