assertTrue(item1.equals(item1));

        // Same input value (id doesn't matter)
        assertTrue(item1.equals(item2));
        assertTrue(item1.equals(item3));

        // Different input value
        assertFalse(item1.equals(item4));

        // Null and different class
        assertFalse(item1.equals(null));
        assertFalse(item1.equals("string"));
        assertFalse(item1.equals(new Object()));
    }

        ProtwordsItem item4 = new ProtwordsItem(1, "word");

        // Same object
        assertTrue(item1.equals(item1));

        // Same input, different id
        assertTrue(item1.equals(item2));

        // Different input
        assertFalse(item1.equals(item3));

        // Same id and input
        assertTrue(item1.equals(item4));

        CharMappingItem item4 = new CharMappingItem(4L, inputs1, "different");

        // Test reflexivity
        assertTrue(item1.equals(item1));

        // Test symmetry and arrays with different order
        assertTrue(item1.equals(item2));
        assertTrue(item2.equals(item1));

        // Test with different inputs
        assertFalse(item1.equals(item3));

        assertTrue(result.isPresent());
        assertEquals(testValue, result.get());
    }

    public void test_ofNullable_withList() {
        List<String> testValue = Arrays.asList("item1", "item2", "item3");
        OptionalEntity<List<String>> result = OptionalUtil.ofNullable(testValue);

        assertNotNull(result);
        assertTrue(result.isPresent());
        assertEquals(testValue, result.get());

    public void test_evaluate_withArrayParameter() {
        String template = "Items: ${items}";
        Map<String, Object> paramMap = new HashMap<>();
        String[] items = { "item1", "item2", "item3" };
        paramMap.put("items", items);

        Object result = scriptEngine.evaluate(template, paramMap);
        assertTrue(result.toString().contains("item1"));
    }

    // Test evaluate method returns different object type

        // Test getting non-existing item
        OptionalEntity<ProtwordsItem> item = protwordsFile.get(999);
        assertFalse(item.isPresent());
    }

    public void test_get_withUnloadedData() {
        // Test getting item when data is not loaded yet
        OptionalEntity<ProtwordsItem> item = protwordsFile.get(1);
        assertTrue(item.isPresent());
        assertEquals("test1", item.get().getInput());
    }

        assertEquals(2, result.size());

        CharMappingItem item1 = result.get(0);
        assertArrayEquals(new String[] { "α", "β" }, item1.getInputs());
        assertEquals("γ", item1.getOutput());

        CharMappingItem item2 = result.get(1);
        assertArrayEquals(new String[] { "中", "文" }, item2.getInputs());
        assertEquals("字", item2.getOutput());
    }

    // Test with very long input line

     *
     * @param item the character mapping item to update
     */
    @Override
    public synchronized void update(final CharMappingItem item) {
        try (MappingUpdater updater = new MappingUpdater(item)) {
            reload(updater);
        }
    }

    /**
     * Deletes a character mapping item from the dictionary file.
     *

   */
  private E extract() {
    E[] items = this.items;
    E x = items[takeIndex];
    items[takeIndex] = null;
    takeIndex = inc(takeIndex);
    --count;
    return x;
  }

  /**
   * Utility for remove and iterator.remove: Delete item at position i. Call only when occupying
   * monitor.
   */
  void removeAt(int i) {
    E[] items = this.items;
    // if removing front item, just advance

                                            <c:forEach var="p" varStatus="s"
                                                       items="${pager.pageNumberList}">
                                                <li
                                                        <c:if test="${p == pager.currentPageNumber}">class="page-item active"</c:if>>
                                                    <la:link