if (artifact.getVersion() == null) {
                    // set the recommended version
                    ArtifactVersion selected = artifact.getSelectedVersion();
                    // MNG-2123: null is a valid response to getSelectedVersion, don't
                    // assume it won't ever be.
                    if (selected != null) {
                        artifact.selectVersion(selected.toString());

              }
            });

    List<Integer> actual = Lists.newArrayList(result);
    List<Integer> expected = asList(1, 2, 3);
    assertEquals(expected, actual);
  }

  public void testTransformRemove() {
    List<String> list = Lists.newArrayList("1", "2", "3");
    Iterator<String> input = list.iterator();
    Iterator<Integer> iterator =
        Iterators.transform(
            input,

        void testEncodeDoesNotModifyBeyondArea() {
            // Given
            byte testByte = (byte) 0xEE;
            Arrays.fill(buffer, testByte);
            SrvCopychunk chunk = new SrvCopychunk(1, 2, 3);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, chunk);
            int expectedSize = HEADER_SIZE + CHUNK_SIZE;

            // When
            copy.encode(buffer, startIndex);

        String floatKey = "numeric.float";

        System.setProperty(Constants.FESS_CONFIG_PREFIX + intKey, "123");
        System.setProperty(Constants.FESS_CONFIG_PREFIX + floatKey, "45.67");

        try {
            String intValue = fessConfig.get(intKey);
            assertEquals("123", intValue);

            String floatValue = fessConfig.get(floatKey);
            assertEquals("45.67", floatValue);

    assertEquals("%s 1 2", Strings.lenientFormat("%s %s %s", "%s", 1, 2));
    assertEquals(" [5, 6]", Strings.lenientFormat("", 5, 6));
    assertEquals("123", Strings.lenientFormat("%s%s%s", 1, 2, 3));
    assertEquals("1%s%s", Strings.lenientFormat("%s%s%s", 1));
    assertEquals("5 + 6 = 11", Strings.lenientFormat("%s + 6 = 11", 5));
    assertEquals("5 + 6 = 11", Strings.lenientFormat("5 + %s = 11", 6));

    public void testEqualsIgnoreSequence() throws Exception {
        assertThat(ArrayUtil.equalsIgnoreSequence(new Object[] { "1" }, new Object[] { "1" }), is(true));
        assertThat(ArrayUtil.equalsIgnoreSequence(new Object[] { "1", "2", "3" }, new Object[] { "2", "3", "1" }), is(true));
        assertThat(ArrayUtil.equalsIgnoreSequence(new Object[] { "1" }, new Object[] { "2" }), is(not(true)));

    for (int i = 0; i < 23; i++) {
      counter.recordMisses(1);
    }
    for (int i = 0; i < 27; i++) {
      counter.recordEviction();
    }
    CacheStats stats = counter.snapshot();
    int requestCount = 11 + 23;
    assertEquals(requestCount, stats.requestCount());
    assertEquals(11, stats.hitCount());
    assertThat(stats.hitRate()).isEqualTo(11.0 / requestCount);
    int missCount = 23;

			t.Errorf("want full output %q, got %q", text, got)
		}
	}
	wantErr = regexp.MustCompile("^no exit code")
	check("abc")
	check("exitcode")
	check("exitcode=")
	check("exitcode=123\n")
	wantErr = regexp.MustCompile("^bad exit code: .* value out of range")
	check("exitcode=999999999999999999999999")

 * 80..95 : Offset by a fixed positive offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].
 *    123 : Mapped inline to the sequence: [b2a].
 *    124 : Mapped inline to the sequence: [b2, b3].
 *    125 : Mapped inline to the sequence: [b2a, b3].
 *    126 : Mapped inline to the sequence: [b2, b3a].

        assertSame(enc, session.getEncryptionContext());

        byte[] encOut = session.encryptMessage(new byte[] { 1, 2, 3 });
        assertArrayEquals(new byte[] { 9, 9 }, encOut);
        verify(enc, times(1)).encryptMessage(eq(new byte[] { 1, 2, 3 }), eq(99L));

        byte[] decOut = session.decryptMessage(new byte[] { 5 });
        assertArrayEquals(new byte[] { 7, 7 }, decOut);