# Note: We intentionally don't add the flags we'd need to make Flags and Enums
# work. That's because the Proguard configuration required to make them work on
# optimized code would preclude lots of optimization, like converting enums
# into ints.

# Throwables uses internal APIs for lazy stack trace resolution
-dontnote sun.misc.SharedSecrets
-keep class sun.misc.SharedSecrets {
  *** getJavaLangAccess(...);
}
-dontnote sun.misc.JavaLangAccess

	if err != nil {
		t.Fatal(err)
	}

	// Make 9 disks offline, which leaves less than quorum number of disks
	// in a 16 disk Erasure setup. The original disks are 'replaced' with
	// naughtyDisks that fail after 'f' successful StorageAPI method
	// invocations, where f - [0,4)
	for f := 0; f < 2; f++ {
		diskErrors := make(map[int]error)
		for i := 0; i <= f; i++ {
			diskErrors[i] = nil
		}

patch -p1 < /gcc9-fixups.patch
patch -p1 < /stringop_trunc.patch
cd ../glibc-build
../glibc-src/configure --prefix=/usr --disable-werror --enable-obsolete-rpc --disable-profile
make -j$(nproc)
make install DESTDIR=${TARGET}
cd ..

# Symlinks in the binary distribution are set up for installation in /usr, we
# need to fix up all the links to stay within /${TARGET}.
/fixlinks.sh "/${TARGET}"

	})
	testCancel(func() {
		rb.Write(make([]byte, sz))
		rb.WriteByte(0)
	})
	testCancel(func() {
		rb.Read([]byte{10: 1})
	})
	testCancel(func() {
		rb.ReadByte()
	})
	testCancel(func() {
		rb.Write(make([]byte, sz))
		rb.Flush()
	})
}

func TestWriteAfterWriterClose(t *testing.T) {
	rb := New(100).SetBlocking(true)

	done := make(chan error)
	go func() {
		defer close(done)

	}

	format, err := getFormatJSON(localDisks[0].path)
	if err != nil {
		log.Fatal(err)
	}

	setSize := len(format.XL.Sets[0])

	expectedDisksName := make(map[string]string)
	actualDisksName := make(map[string]string)

	// Calculate the set/disk index
	for _, disk := range localDisks {
		expectedDisksName[fmt.Sprintf("%d-%d", disk.index/setSize, disk.index%setSize)] = disk.path

	// with less quorum return error.
	if quorum < 1 {
		return FileInfo{}, InsufficientReadQuorum{Err: errErasureReadQuorum, Type: RQInsufficientOnlineDrives}
	}
	metaHashes := make([]string, len(metaArr))
	h := sha256.New()
	for i, meta := range metaArr {
		if !meta.IsValid() {
			continue
		}
		etagOnly := modTime.Equal(timeSentinel) && (etag != "" && etag == meta.Metadata["etag"])

	Webhook map[string]target.WebhookArgs `json:"webhook"`
}

const (
	defaultTarget = "1"
)

// NewConfig - initialize lambda config.
func NewConfig() Config {
	// Make sure to initialize lambda targets
	cfg := Config{
		Webhook: make(map[string]target.WebhookArgs),
	}
	cfg.Webhook[defaultTarget] = target.WebhookArgs{}
	return cfg

				time.Sleep(wait)
			}
		}
		i++
		wk.Take()
		go func(toExpire []expireObjInfo) {
			defer wk.Give()

			toExpireAll := make([]ObjectInfo, 0, len(toExpire))
			toDel := make([]ObjectToDelete, 0, len(toExpire))
			oiCache := newObjInfoCache()
			for _, exp := range toExpire {
				if exp.ExpireAll {
					toExpireAll = append(toExpireAll, exp.ObjectInfo)
					continue

    // make sure that no exception is thrown regardless of value of
    // 'swallowException' when the mock does not throw an exception.
    setupCloseable(false);
    doClose(mockCloseable, false, false);

    setupCloseable(false);
    doClose(mockCloseable, true, false);
  }

  public void testClose_closeableWithEatenException() throws IOException {

		// not be required but makes reproduction much easier.
		nsLk.lockMapMutex.Lock()

		// lk3 blocks.
		lk3ch := make(chan bool)
		go func() {
			lk3ch <- nsLk.lock(ctx, "volume", "path", "source", "opsID", false, 0)
		}()

		// lk4, blocks.
		lk4ch := make(chan bool)
		go func() {
			lk4ch <- nsLk.lock(ctx, "volume", "path", "source", "opsID", false, 0)
		}()
		runtime.Gosched()