ret[1] = className.substring(i + 1);
        } else {
            ret[1] = className;
        }
        return ret;
    }

    /**
     * Returns the class name itself, or for arrays, the element class name with {@literal []} appended.
     *
     * @param clazz
     *            The class. Must not be {@literal null}.
     * @return The class name.
     */

		}
	})

	t.Run("Array", func(t *testing.T) {
		pets := [...]Pet{{
			Name: "PolymorphicHasOne-Array-1",
			Toy:  Toy{Name: "Toy-PolymorphicHasOne-Array-1"},
		}, {
			Name: "PolymorphicHasOne-Array-2",
			Toy:  Toy{Name: "Toy-PolymorphicHasOne-Array-2"},
		}, {
			Name: "PolymorphicHasOne-Array-3",
			Toy:  Toy{Name: "Toy-PolymorphicHasOne-Array-3"},
		}}

                scopes = Arrays.asList(Artifact.SCOPE_COMPILE, Artifact.SCOPE_SYSTEM, Artifact.SCOPE_PROVIDED);
            } else if (Artifact.SCOPE_RUNTIME.equals(classpath)) {
                scopes = Arrays.asList(Artifact.SCOPE_COMPILE, Artifact.SCOPE_RUNTIME);
            } else if (Artifact.SCOPE_COMPILE_PLUS_RUNTIME.equals(classpath)) {
                scopes = Arrays.asList(

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.helper;

import java.util.Arrays;

import javax.annotation.PostConstruct;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.commonmark.Extension;
import org.commonmark.ext.gfm.tables.TablesExtension;

  @SuppressWarnings("DoNotCall")
  public void testRemove() {
    String[] array = {"a", "b", "c"};

    Iterator<String> iterator =
        new UnmodifiableIterator<String>() {
          int i;

          @Override
          public boolean hasNext() {
            return i < array.length;
          }

          @Override
          public String next() {
            if (!hasNext()) {

    }

    /**
     * Sets the command array for user update operations.
     * @param updateCommand The update command array.
     */
    public void setUpdateCommand(final String[] updateCommand) {
        this.updateCommand = updateCommand;
    }

    /**
     * Sets the command array for user deletion operations.
     * @param deleteCommand The delete command array.
     */

   *     ImmutableSetMultimap.<Character, Character>builder()
   *         .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
   *         .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
   *         .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
   *         .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
   *         .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
   *         .build();
   *

  @CollectionSize.Require(absent = ZERO)
  public void testAdd_supportedNullPresent() {
    E[] array = createArrayWithNullElement();
    collection = getSubjectGenerator().create(array);
    assertTrue("add(nullPresent) should return true", getList().add(null));

    List<E> expected = copyToList(array);
    expected.add(null);
    expectContents(expected);
  }

  /**

        this.numHashFunctions,
        that.numHashFunctions);
    checkArgument(
        this.bitSize() == that.bitSize(),
        "BloomFilters must have the same size underlying bit arrays (%s != %s)",
        this.bitSize(),
        that.bitSize());
    checkArgument(
        this.strategy.equals(that.strategy),
        "BloomFilters must have equal strategies (%s != %s)",
        this.strategy,

        while (i > 0) {
            buf[index - i] = value;
            i--;
        }
        return n;
    }

    /**
     * Writes an octet array to the buffer.
     *
     * @param b the byte array to write
     * @param i the starting index in the array
     * @param l the number of bytes to write
     */
    public void writeOctetArray(final byte[] b, final int i, final int l) {