//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"bytes"
	"crypto/rand"
	"io"
	"os"
	"testing"
)

var erasureHealTests = []struct {
	dataBlocks, disks int

	// number of offline disks is also number of staleDisks for
	// erasure reconstruction in this test

            0L -> -1L // No more bytes in this part.
            else -> source.read(sink, limit)
          }
        }
      }

      override fun timeout(): Timeout = timeout
    }

    /**
     * Returns a value in [0..maxByteCount] with the number of bytes that can be read from [source]

            // When
            chunk.encode(buffer, startIndex);

            // Then
            // Check bytes before encoded area
            for (int i = 0; i < startIndex; i++) {
                assertEquals(testByte, buffer[i], "Byte at position " + i + " was modified");
            }

            // Check bytes after encoded area
            for (int i = startIndex + EXPECTED_SIZE; i < buffer.length; i++) {

		"Distribution of time to first byte across API calls", "name", "type", "le")

	apiTrafficSentBytesMD = NewCounterMD(apiTrafficSentBytes,
		"Total number of bytes sent", "type")
	apiTrafficRecvBytesMD = NewCounterMD(apiTrafficRecvBytes,
		"Total number of bytes received", "type")
)

// loadAPIRequestsHTTPMetrics - reads S3 HTTP metrics.
//
// This is a `MetricsLoaderFn`.
//
// This includes node level S3 HTTP metrics.

                + (lmResponse == null ? "null" : "<" + lmResponse.length + " bytes>") + ",ntResponse="
                + (ntResponse == null ? "null" : "<" + ntResponse.length + " bytes>") + ",sessionKey="
                + (sessionKey == null ? "null" : "<" + sessionKey.length + " bytes>") + ",flags=0x"
                + jcifs.smb1.util.Hexdump.toHexString(getFlags(), 8) + "]";
    }

    /**

        }

        this.timeout100Ns = SMBUtil.readInt4(buffer, bufferIndex) & 0xFFFFFFFFL; // Timeout (4 bytes, 100-ns intervals, unsigned)
        this.flags = SMBUtil.readInt4(buffer, bufferIndex + 4); // Flags (4 bytes)
        return 8;
    }

    /**
     * Get the timeout value in 100-nanosecond intervals (raw wire format)
     * @return the timeout in 100-nanosecond intervals

  static TestSuite suiteForBytes(
      CharSourceFactory factory, byte[] bytes, String name, String desc, boolean slice) {
    TestSuite suite = suiteForString(factory, new String(bytes, UTF_8), name, desc);
    ByteSourceFactory byteSourceFactory = SourceSinkFactories.asByteSourceFactory(factory);
    suite.addTest(
        ByteSourceTester.suiteForBytes(
            byteSourceFactory, bytes, name + ".asByteSource[Charset]", desc, slice));
    return suite;

 * bytes in length.
 *
 * The cache stores its data in a directory on the filesystem. This directory must be exclusive to
 * the cache; the cache may delete or overwrite files from its directory. It is an error for
 * multiple processes to use the same cache directory at the same time.
 *
 * This cache limits the number of bytes that it will store on the filesystem. When the number of

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {
    listener.onMessage(this, text)
  }

  @Throws(IOException::class)
  override fun onReadMessage(bytes: ByteString) {
    listener.onMessage(this, bytes)
  }

  @Synchronized override fun onReadPing(payload: ByteString) {
    // Don't respond to pings after we've failed or sent the close frame.

      throws IOException {
    byte[] bytes = decoded.getBytes(UTF_8);
    try (InputStream decodingStream = encoding.decodingStream(new StringReader(encoded))) {
      for (int i = 0; i < bytes.length; i++) {
        assertThat(decodingStream.read()).isEqualTo(bytes[i] & 0xFF);
      }
      assertThat(decodingStream.read()).isEqualTo(-1);
    }
  }