return null;
          }
        };
    Callables.threadRenaming(callable, newName).call();
    assertEquals(oldName, Thread.currentThread().getName());
  }

  @J2ktIncompatible
  @GwtIncompatible // threads
  public void testRenaming_exceptionalReturn() throws Exception {
    String oldName = Thread.currentThread().getName();
    final Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");

            return null;
          }
        };
    Callables.threadRenaming(callable, newName).call();
    assertEquals(oldName, Thread.currentThread().getName());
  }

  @J2ktIncompatible
  @GwtIncompatible // threads
  public void testRenaming_exceptionalReturn() throws Exception {
    String oldName = Thread.currentThread().getName();
    final Supplier<String> newName = Suppliers.ofInstance("MyCrazyThreadName");

	GetTypeAliases(databaseTypeName string) []string

	// Tables
	CreateTable(dst ...interface{}) error
	DropTable(dst ...interface{}) error
	HasTable(dst interface{}) bool
	RenameTable(oldName, newName interface{}) error
	GetTables() (tableList []string, err error)
	TableType(dst interface{}) (TableType, error)

	// Columns
	AddColumn(dst interface{}, field string) error

    return () -> {
      Thread currentThread = Thread.currentThread();
      String oldName = currentThread.getName();
      boolean restoreName = trySetName(nameSupplier.get(), currentThread);
      try {
        return callable.call();
      } finally {
        if (restoreName) {
          boolean unused = trySetName(oldName, currentThread);
        }
      }
    };
  }

  /**

func (RealOS) MkdirAll(path string, perm os.FileMode) error {
	return os.MkdirAll(path, perm)
}

// Symlink will call os.Symlink to create a symbolic link.
func (RealOS) Symlink(oldname string, newname string) error {
	return os.Symlink(oldname, newname)
}

// Stat will call os.Stat to get the FileInfo for a given path
func (RealOS) Stat(path string) (os.FileInfo, error) {
	return os.Stat(path)
}

    return () -> {
      Thread currentThread = Thread.currentThread();
      String oldName = currentThread.getName();
      boolean restoreName = trySetName(nameSupplier.get(), currentThread);
      try {
        return callable.call();
      } finally {
        if (restoreName) {
          boolean unused = trySetName(oldName, currentThread);
        }
      }
    };
  }

  /**

	if f.MkdirAllFn != nil {
		return f.MkdirAllFn(path, perm)
	}
	return nil
}

// Symlink is a fake call that just returns nil.
func (f *FakeOS) Symlink(oldname string, newname string) error {
	if f.SymlinkFn != nil {
		return f.SymlinkFn(oldname, newname)
	}
	return nil
}

// Stat is a fake that returns an error
func (f *FakeOS) Stat(path string) (os.FileInfo, error) {
	if f.StatFn != nil {

// when in fact the algorithm is faster than the standard one.
func Diff(oldName string, old []byte, newName string, new []byte) []byte {
	if bytes.Equal(old, new) {
		return nil
	}
	x := lines(old)
	y := lines(new)

	// Print diff header.
	var out bytes.Buffer
	fmt.Fprintf(&out, "diff %s %s\n", oldName, newName)
	fmt.Fprintf(&out, "--- %s\n", oldName)
	fmt.Fprintf(&out, "+++ %s\n", newName)

	// Loop over matches to consider,

limitations under the License.
*/

package promise

import (
	"context"
	"testing"
	"time"

	"k8s.io/apimachinery/pkg/util/wait"
)

func TestWriteOnceSet(t *testing.T) {
	oldTime := time.Now()
	cval := &oldTime
	ctx, cancel := context.WithCancel(context.Background())
	wr := NewWriteOnce(nil, ctx, cval)
	gots := make(chan interface{})
	goGetExpectNotYet(t, wr, gots, "Set")
	now := time.Now()
	aval := &now

    static class OldSuper {}

    static class OldBase extends OldSuper {}

    static class NewSuper {}

    static class NewBase extends NewSuper {}

    @Incubating
    static class NewIncubatingBase extends NewSuper {}

    @Incubating
    interface IncubatingInterface {}

    interface InternalInterface {}

    interface StablePublicInterface {}

    CtClass oldBase
    CtClass newBase
    CtClass newSuper