testRotate(new short[] {1}, 0, 0, 1, new short[] {1});
    testRotate(new short[] {1}, 1, 0, 1, new short[] {1});
    testRotate(new short[] {1}, 1, 1, 1, new short[] {1});

    // Rotate the central 5 elements, leaving the ends as-is
    testRotate(new short[] {0, 1, 2, 3, 4, 5, 6}, -6, 1, 6, new short[] {0, 2, 3, 4, 5, 1, 6});
    testRotate(new short[] {0, 1, 2, 3, 4, 5, 6}, -1, 1, 6, new short[] {0, 2, 3, 4, 5, 1, 6});

                            return 1; 
                        } else {
                            return -1;
                        }
                    });
                    // Remove duplicates (equal adjacent elements) - a new, un@Incubating type will be here twice, as 2 errors are reported; use stringified JSON to compare
                    // Filtering an array is NOT in place

package lifecycle

import (
	"encoding/xml"
	"fmt"
	"testing"

	"github.com/dustin/go-humanize"
)

// TestUnsupportedFilters checks if parsing Filter xml with
// unsupported elements returns appropriate errors
func TestUnsupportedFilters(t *testing.T) {
	testCases := []struct {
		inputXML    string
		expectedErr error
	}{
		{ // Filter with And tags
			inputXML: ` <Filter>
						<And>

   * network that does not allow them will throw an {@link IllegalArgumentException}.
   */
  boolean allowsParallelEdges();

  /** Returns the order of iteration for the elements of {@link #edges()}. */
  ElementOrder<E> edgeOrder();

  //
  // Element-level accessors
  //

  /**
   * Returns a live view of the edges whose {@link #incidentNodes(Object) incident nodes} in this
   * network include {@code node}.
   *

    }
    return ImmutableEnumMap.asImmutable(enumMap);
  }

  /**
   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableMap} whose keys
   * and values are the result of applying the provided mapping functions to the input elements. The
   * resulting implementation is specialized for enum key types. The returned map and its views will

    }
    return ImmutableEnumMap.asImmutable(enumMap);
  }

  /**
   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableMap} whose keys
   * and values are the result of applying the provided mapping functions to the input elements. The
   * resulting implementation is specialized for enum key types. The returned map and its views will

        });

        // When: Create iterator with rejecting filter
        NetServerEnumIterator iterator = new NetServerEnumIterator(parent, treeHandle, "*", 0, nameFilter);

        // Then: Iterator should have no elements
        assertFalse(iterator.hasNext());

        // Cleanup
        iterator.close();
    }

    @Test
    @DisplayName("Iterator should handle filter that throws CIFSException")

}

// defaultMaxSize defines the default maximum capacity of the cache.
// Its value is the maximum value of the int64 type, which means that when the cache size is not specified,
// the cache can theoretically store as many elements as possible.
// (1 << 63) - 1 is the maximum value that an int64 type can represent.
const (
	defaultMaxSize = math.MaxInt
	// defaultTTL defines the default time-to-live (TTL) for each cache entry.

     *         If all functions return null, the composite function returns null.
     *
     * @throws NullPointerException if the input collection is null or contains null elements.
     */
    static UnaryOperator<String> chain(Collection<? extends UnaryOperator<String>> functions) {
        return s -> {
            for (UnaryOperator<String> function : functions) {

 * invoke methods, they invoke methods on the {@code ForwardingNavigableSet}.
 *
 * <p>Each of the {@code standard} methods uses the set's comparator (or the natural ordering of the
 * elements, if there is no comparator) to test element equality. As a result, if the comparator is
 * not consistent with equals, some of the standard implementations may violate the {@code Set}
 * contract.
 *