public void testInterruptThrows() throws Exception {
    CountDownLatch isInterruptibleRegistered = new CountDownLatch(1);
    SettableFuture<String> taskResult = SettableFuture.create();
    InterruptibleTask<String> task =
        new InterruptibleTask<String>() {
          @Override
          String runInterruptibly() throws Exception {
            BrokenChannel bc = new BrokenChannel();
            bc.doBegin();

  public void testInterruptThrows() throws Exception {
    CountDownLatch isInterruptibleRegistered = new CountDownLatch(1);
    SettableFuture<String> taskResult = SettableFuture.create();
    InterruptibleTask<String> task =
        new InterruptibleTask<String>() {
          @Override
          String runInterruptibly() throws Exception {
            BrokenChannel bc = new BrokenChannel();
            bc.doBegin();

    tearDownStack.runTearDown();
  }

  private String enter() {
    return interruptible ? "enterInterruptibly" : "enter";
  }

  private String tryEnter() {
    return "tryEnter";
  }

  private String enterIf() {
    return interruptible ? "enterIfInterruptibly" : "enterIf";
  }

  private String tryEnterIf() {
    return "tryEnterIf";
  }

  private String enterWhen() {

		}

		if !testCase.expectErr {
			if !reflect.DeepEqual(data, testCase.expectedData) {
				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
			}
		}
	}
}

func TestNameUnmarshalXML(t *testing.T) {
	var blankName Name

	testCases := []struct {
		data         []byte
		expectedName Name

    protected Pattern userAgentPattern;

    protected Pattern regexPattern;

    protected BiFunction<String, Matcher, String> pathMapperFunc;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    /** line to add at the top of the target file */
    private String headerLine;

    private File target;

    private List<String> additionalLines = new ArrayList<>();

    public void setFiles(FileTree files) {
        this.files = files;
    }

    @InputFiles
    public FileTree getFiles() {
        return files;
    }

    public void setHeaderLine(String headerLine) {
        this.headerLine = headerLine;
    }

        @Override
        @Nullable String chop(String str) {
          String result = i.chop(str);
          return result != null ? result : you.chop(str);
        }
      };
    }

    abstract @Nullable String chop(String str);

    static Chopper suffix(String suffix) {
      return new Chopper() {
        @Override
        @Nullable String chop(String str) {
          if (str.endsWith(suffix)) {

//go:generate msgp -file=$GOFILE

// ServerSystemConfig - captures information about server configuration.
type ServerSystemConfig struct {
	NEndpoints int
	CmdLines   []string
	MinioEnv   map[string]string
	Checksum   string
}

// Diff - returns error on first difference found in two configs.
func (s1 *ServerSystemConfig) Diff(s2 *ServerSystemConfig) error {
	if s1.Checksum != s2.Checksum {

     * @param message the detailed error message
     */
    public InvalidAccessTokenException(final String type, final String message) {
        super(message);
        this.type = type;
    }

    /**
     * Returns the type of the invalid access token.
     *
     * @return the type of the invalid access token
     */
    public String getType() {
        return type;
    }

 */
public class MultiIteratorTest {

    /**
     *
     */
    @Test
    public void test() {
        final List<String> list1 = asList("Foo", "Bar");
        final List<String> list2 = asList("Baz");

        @SuppressWarnings("unchecked")
        final Iterator<String> it = new MultiIterator<String>(list1.iterator(), list2.iterator());

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Foo"));