if err != nil {
		t.Fatalf("Expected GetObject reading data to succeed, but failed with %v", err)
	}
	gr.Close()

	const expectedHash = "fffb6377948ebea75ad2b8058e849ef5"
	foundHash := fmt.Sprintf("%x", h.Sum(nil))
	if foundHash != expectedHash {
		t.Fatalf("Expected data to have md5sum = `%s`, found `%s`", expectedHash, foundHash)
	}
}

// Test reading an object with some outdated data in some disks

        }

        @Test
        @DisplayName("Test read string with odd Unicode alignment")
        void testReadStringUnicodeAlignment() {
            testBlock.setUseUnicode(true);
            // Test reading Unicode string with alignment

            byte[] buffer = new byte[100];
            // Write "Test" in UTF-16LE directly at position 2 (even offset)

        this.allow = buf[bi] == (byte) 0x00;
        bi++;
        this.flags = buf[bi++] & 0xFF;
        final int size = SMBUtil.readInt2(buf, bi);
        bi += 2;
        this.access = SMBUtil.readInt4(buf, bi);
        bi += 4;
        this.sid = new SID(buf, bi);
        return size;
    }

    void appendCol(final StringBuffer sb, final String str, final int width) {

Nevertheless, you still enforce those scopes, or any other security/authorization requirement, however you need, in your code.

In many cases, OAuth2 with scopes can be an overkill.

But if you know you need it, or you are curious, keep reading.

///

## OAuth2 scopes and OpenAPI { #oauth2-scopes-and-openapi }

The OAuth2 specification defines "scopes" as a list of strings separated by spaces.

        testBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x25) {
            @Override
            protected int readHeaderWireFormat(byte[] buffer, int bufferIndex) {
                // Simulate header reading
                return 33;
            }
        };
        byte[] buffer = new byte[1024];

        // Setup buffer after header
        buffer[33] = 4; // wordCount

		dstRec = &Record{}
	}
	dstRec.object = v
	return dstRec, nil
}

// Close - closes underlying reader.
func (r *Reader) Close() error {
	// Close the input.
	// Potentially racy if the stream decoder is still reading.
	if r.readCloser != nil {
		r.readCloser.Close()
	}
	if r.exitReader != nil {
		close(r.exitReader)
		r.readerWg.Wait()
		r.exitReader = nil
		r.input = nil
	}
	return nil
}

	n, err := r.src.Read(p)
	r.readN += int64(n)
	r.md5.Write(p[:n])

	if err == io.EOF && len(r.checksum) != 0 {
		if etag := r.ETag(); !Equal(etag, r.checksum) {
			return n, VerifyError{
				Expected: r.checksum,
				Computed: etag,
			}
		}
	}
	return n, err
}

// ETag returns the ETag of all the content read
// so far. Reading more content changes the MD5

			i, err = d.object()
		}
		return i, Object, err
	default:
		return nil, Unknown, d.mkError(ErrSyntax, "looking for beginning of value")
	}
}

// string called by `any` or `object`(for map keys) after reading `"`
func (d *Decoder) string() (string, error) {
	d.scratch.reset()
	c := d.next()

scan:
	for {
		switch {
		case c == '"':
			return string(d.scratch.bytes()), nil
		case c == '\\':

    stream.defaultReadObject();
    keyToKeyList = new LinkedHashMap<>();
    int size = stream.readInt();
    for (int i = 0; i < size; i++) {
      @SuppressWarnings("unchecked") // reading data stored by writeObject
      K key = (K) stream.readObject();
      @SuppressWarnings("unchecked") // reading data stored by writeObject
      V value = (V) stream.readObject();
      put(key, value);
    }
  }

Calls can be canceled from any thread. This will fail the call if it hasn’t yet completed! Code that is writing the request body or reading the response body will suffer an `IOException` when its call is canceled.

## Dispatch