assertEquals(value, ResourceUtil.resolve(value));

        value = "${abc.xyz}";
        assertEquals(value, ResourceUtil.resolve(value));

        System.setProperty("abc", "123");

        value = "${abc}";
        assertEquals("123", ResourceUtil.resolve(value));

        value = "xxx${abc}zzz";
        assertEquals("xxx123zzz", ResourceUtil.resolve(value));

        value = "${abc.xyz}";

  }

  /**
   * Returns a string containing the supplied {@code int} values separated by {@code separator}. For
   * example, {@code join("-", 1, 2, 3)} returns the string {@code "1-2-3"}.
   *
   * @param separator the text that should appear between consecutive values in the resulting string
   *     (but not at the start or end)

        assertEquals("", data.getDataMap().get("key2"));
    }

    public void test_register_primitives() {
        RenderData data = new RenderData();

        RenderDataUtil.register(data, "int", 123);
        assertEquals(123, data.getDataMap().get("int"));

        RenderDataUtil.register(data, "long", 456L);
        assertEquals(456L, data.getDataMap().get("long"));

        RenderDataUtil.register(data, "boolean", true);

        StopwordsItem item = new StopwordsItem(123, "word");
        assertEquals("StopwordsItem [id=123, inputs=word, newInputs=null]", item.toString());

        item.setNewInput("updated");
        assertEquals("StopwordsItem [id=123, inputs=word, newInputs=updated]", item.toString());

        item.setNewInput("");
        assertEquals("StopwordsItem [id=123, inputs=word, newInputs=]", item.toString());
    }

            @Override
            public String toString() {
                return "TestScheduledJob[id=123]";
            }
        };

        JobNotFoundException exception = new JobNotFoundException(scheduledJob);

        assertNotNull(exception);
        assertEquals("TestScheduledJob[id=123]", exception.getMessage());
        assertNull(exception.getCause());
    }

    assertThat(set.headSet(4)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(Integer.MAX_VALUE)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(1, true)).containsExactly(1).inOrder();
    assertThat(set.headSet(2, true)).containsExactly(1, 2).inOrder();
    assertThat(set.headSet(3, true)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(4, true)).containsExactly(1, 2, 3).inOrder();

        assertNull(StringConversionUtil.fromWindowsMapping(null));
        assertEquals("", StringConversionUtil.fromWindowsMapping(""));
        assertEquals("abc 123", StringConversionUtil.fromWindowsMapping("abc 123"));
        assertEquals("abc\uFF5E\u2225\uFF0D\uFFE0\uFFE1\uFFE2",
                StringConversionUtil.fromWindowsMapping("abc\u301C\u2016\u2212\u00A2\u00A3\u00AC"));
    }

    /**

    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(
            1, MODIFIABLE, newArrayList(1, 2, 3), IteratorTester.KnownOrder.KNOWN_ORDER) {
          @Override
          protected Iterator<Integer> newTargetIterator() {
            return Lists.newArrayList(1, 2, 3).iterator();
          }

          @Override
          protected void verify(List<Integer> elements) {

        text = "123";
        queries = new String[] { "123" };
        assertEquals("<strong>123</strong>", viewHelper.replaceHighlightQueries(text, queries));

        text = "abc123efg";
        queries = new String[] { "123" };
        assertEquals("abc<strong>123</strong>efg", viewHelper.replaceHighlightQueries(text, queries));

        text = "123";
        queries = new String[] { "123", "456" };

   * NumberFormatException} if the input string is invalid.
   *
   * <p><b>Warning:</b> please see {@link Short#decode} to understand exactly how strings are
   * parsed. For example, the string {@code "0123"} is treated as <i>octal</i> and converted to the
   * value {@code 83}.
   *
   * @since 16.0
   */
  public static Converter<String, Short> stringConverter() {
    return ShortConverter.INSTANCE;
  }