public void testRotate() {
    testRotate(new boolean[] {}, -1, new boolean[] {});
    testRotate(new boolean[] {}, 0, new boolean[] {});
    testRotate(new boolean[] {}, 1, new boolean[] {});

    testRotate(new boolean[] {true}, -2, new boolean[] {true});
    testRotate(new boolean[] {true}, -1, new boolean[] {true});
    testRotate(new boolean[] {true}, 0, new boolean[] {true});
    testRotate(new boolean[] {true}, 1, new boolean[] {true});

	}
	if len(extKey) != 32 { // safety check
		logger.CriticalIf(context.Background(), errors.New("crypto: invalid key length"))
	}
	var nonce [32]byte
	if _, err := io.ReadFull(random, nonce[:]); err != nil {
		logger.CriticalIf(context.Background(), errOutOfEntropy)
	}

	const Context = "object-encryption-key generation"
	mac := hmac.New(sha256.New, extKey)
	mac.Write([]byte(Context))
	mac.Write(nonce[:])
	mac.Sum(key[:0])
	return key

          }
        };
    static final PermittedMetaException UOE =
        new PermittedMetaException("UnsupportedOperationException") {
          @Override
          boolean isPermitted(Exception exception) {
            return exception instanceof UnsupportedOperationException;
          }
        };
    static final PermittedMetaException ISE =
        new PermittedMetaException("IllegalStateException") {
          @Override

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"errors"
)

var (
	errLockConflict       = errors.New("lock conflict")
	errLockNotInitialized = errors.New("lock not initialized")
	errLockNotFound       = errors.New("lock not found")

    private List<Server> servers;

    private List<Mirror> mirrors;

    private List<Profile> profiles;

    private final ProjectActivation projectActivation = new ProjectActivation();
    private final ProfileActivation profileActivation = new ProfileActivation();

    private List<String> pluginGroups;

    private boolean isProjectPresent = true;

/**
 * Unit test for simple App.
 */
public class AppTest {
  private final MockWebServer mockWebServer = new MockWebServer();

  @Test
  public void testApp() throws IOException {
    mockWebServer.enqueue(new MockResponse(200, Headers.of(), "Hello, Maven!"));
    mockWebServer.start();

    new SampleHttpClient().makeCall(mockWebServer.url("/"));
  }

 * the same parameters forwarded and return value forwarded back or exception propagated as is.
 *
 * <p>For example:
 *
 * {@snippet :
 * new ForwardingWrapperTester().testForwarding(Foo.class, new Function<Foo, Foo>() {
 *   public Foo apply(Foo foo) {
 *     return new ForwardingFoo(foo);
 *   }
 * });
 * }
 *
 * @author Ben Yu
 * @since 14.0
 */
@GwtIncompatible
@J2ktIncompatible
@NullMarked

            MethodMetaData methodMetaData = new MethodMetaData(id, extensionDoc.getTargetClass().getClassMetaData());
            methodMetaData.addParameter("configClosure", new TypeMetaData(Closure.class.getName()));
            MethodDoc methodDoc = new MethodDoc(methodMetaData, Collections.singletonList(para));
            extensionDoc.getExtraBlocks().add(new BlockDoc(methodDoc, propertyDoc, propertyMetaData.getType(), false));

    URL url1 = new URL("file:/a");
    URL url2 = new URL("file:/b");
    URLClassLoader grandParent = new URLClassLoader(new URL[] {url1}, null);
    URLClassLoader parent = new URLClassLoader(new URL[] {url2}, grandParent);
    assertThat(ClassPath.getClassPathEntries(new ClassLoader(parent) {}))
        .containsExactly(new File("/a"), grandParent, new File("/b"), parent);
  }

  private static final ImmutableRangeSet<Comparable<?>> EMPTY =
      new ImmutableRangeSet<>(ImmutableList.of());

  private static final ImmutableRangeSet<Comparable<?>> ALL =
      new ImmutableRangeSet<>(ImmutableList.of(Range.all()));

  /**
   * Returns a {@code Collector} that accumulates the input elements into a new {@code
   * ImmutableRangeSet}. As in {@link Builder}, overlapping ranges are not permitted and adjacent