*     line-termination characters, or {@code null} if the end of the stream has been reached.
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue // to skip a line
  public @Nullable String readLine() throws IOException {
    while (lines.peek() == null) {
      Java8Compatibility.clear(cbuf);
      // The default implementation of Reader#read(CharBuffer) allocates a

            case -1:
                if (tot > 0) {
                    return tot;
                }
                return -1;
            }
        }
    }

    @Override
    public synchronized long skip(final long numbytes) throws IOException {
        if (numbytes <= 0) {
            return 0;
        }
        long n = numbytes;
        while (n > 0) {

	// look ahead for ] - if the array is empty.
	if c = d.skipSpaces(); c == ']' {
		goto out
	}

scan:
	if v, err = d.emitAny(); err != nil {
		goto out
	}

	if d.depth > d.emitDepth { // skip alloc for array if it won't be emitted
		array = append(array, v)
	}

	// next token must be ',' or ']'
	switch c = d.skipSpaces(); c {
	case ',':
		d.skipSpaces()
		goto scan
	case ']':

    @Test
    public void test_roleQuery() {
        queryContext = new QueryContext("test", false);

        // Default should be enabled
        assertTrue(queryContext.roleQueryEnabled());

        // Skip role query
        queryContext.skipRoleQuery();
        assertFalse(queryContext.roleQueryEnabled());
    }

    // Test getDefaultField and setDefaultField
    @Test
    public void test_defaultField() {

        ComponentUtil.getLogNotificationHelper()
                .offer(new LogNotificationEvent(System.currentTimeMillis(), "ERROR", "org.test", "should remain", null));

        // expired() should skip when disabled
        logNotificationTarget.expired();

        // Buffer should still contain the event since disabled check should return early

)

var (
	smallInput  = make([]byte, 1024*12)       // 12K
	mediumInput = make([]byte, 1024*1024*12)  // 12MB
	largeInput  = make([]byte, 1024*1024*128) // 128MB
)

func TestScanner(t *testing.T) {
	t.Skip("Unstable test")
	data := []byte("abcdefghijklmnopqrstuvwxyz0123456789")

	var i int
	r := bytes.NewReader(data)
	scanner := newScanner(r)
	for scanner.pos < atomic.LoadInt64(&scanner.end) {
		c := scanner.next()

      boolean addToSet = true;
      while (iterator.hasNext()) {
        Class<?> current = iterator.next();
        if (current == itf || itf.isAssignableFrom(current)) {
          // Skip any super interface of the ones that are already included.
          addToSet = false;
          break;
        }
      }
      if (addToSet) {
        interfaceClasses.add(itf);
      }
    }

        // Read the transform (only expecting one)
        if (transformCount > 0) {
            rdmaTransformId = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            // Skip reserved fields at bufferIndex + 2 and bufferIndex + 4
            bufferIndex += 6; // 2 + 4 for reserved fields
        }

        return bufferIndex - start;
    }

    @Override
    public int size() {

			fi
		else
		    echo "No versioning action for '$BUCKET'" 
		fi
	else
		echo "Bucket '$BUCKET' versioning unchanged."
	fi

	# At this point, the bucket should exist, skip checking for existence
	# Set policy on the bucket
	echo "Setting policy of bucket '$BUCKET' to '$POLICY'."
	${MC} anonymous set $POLICY myminio/$BUCKET
}

# Try connecting to MinIO instance

      TYPE_PING -> readPing(handler, length, flags, streamId)
      TYPE_GOAWAY -> readGoAway(handler, length, flags, streamId)
      TYPE_WINDOW_UPDATE -> readWindowUpdate(handler, length, flags, streamId)
      else -> source.skip(length.toLong()) // Implementations MUST discard frames of unknown types.
    }

    return true
  }

  @Throws(IOException::class)
  private fun readHeaders(
    handler: Handler,
    length: Int,