// See ../internal/types/testdata/spec/range.go for most tests.
// The ones in this file cannot be expressed in that framework
// due to conflicts between that framework's error location pickiness
// and gofmt's comment location pickiness.

package p

type T struct{}

func (*T) PM() {}
func (T) M()   {}

func test() {

func testblankvars() {
	n := 0
	for range alphabet {
		n++
	}
	if n != 26 {
		println("for range: wrong count", n, "want 26")
		panic("fail")
	}
	n = 0
	for _ = range alphabet {
		n++
	}
	if n != 26 {
		println("for _ = range: wrong count", n, "want 26")
		panic("fail")
	}
	n = 0
	for _, _ = range alphabet {
		n++
	}
	if n != 26 {

	}
	for _ = range f7 {
	}
	for _, _ = range f8 {
	}
	for range 1 {
	}
	for range uint8(1) {
	}
	for range int64(1) {
	}
	for range MyInt(1) {
	}
	for range 'x' {
	}
	for range 1.0 /* ERROR "cannot range over 1.0 (untyped float constant 1)" */ {
	}
	for _ = range MyFunc1(nil) {
	}
	for _ = range MyFunc3(nil) {
	}
	for _ = range (func(MyFunc2))(nil) {
	}

	var i int
	var s string

	var i int

	/*
	 * key only
	 */
	i = 0
	for k := range a {
		v := a[k]
		if v != f(k) {
			println("key array range", k, v, a[k])
			panic("fail")
		}
		i++
	}
	if i != size {
		println("key array size", i)
		panic("fail")
	}

	i = 0
	for k := range p {
		v := p[k]
		if v != f(k) {
			println("key pointer range", k, v, p[k])
			panic("fail")
		}
		i++
	}
	if i != size {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.test.fixtures.concurrent

/**
 * A range of time.
 */
class Range {
    private final long millis

    Range(long millis) {
        this.millis = millis
    }

    @Override
    String toString() {
        return "[approx $millis millis]"
    }

		if !ranges[i].Equals(want[i]) {
			t.Errorf("range %d: got [0x%x, 0x%x), want [0x%x, 0x%x)", i,
				ranges[i].Base(), ranges[i].Limit(),
				want[i].Base(), want[i].Limit(),
			)
		}
		if i != 0 {
			// Ensure the ranges are sorted.
			if ranges[i-1].Base() >= ranges[i].Base() {
				t.Errorf("ranges %d and %d are out of sorted order", i-1, i)
			}
			// Check for a failure to coalesce.
			if ranges[i-1].Limit() == ranges[i].Base() {

deveshkandpal1224 <******@****.***> 1717646003 -0700

Antoine Pelisse <******@****.***> 1581019688 -0800

    NONE_APPLICABLE      text ranges: [(89,92)]
      PSI: KtNameReferenceExpression at (6,5-8)
  for PSI element of type KtNameReferenceExpression at (7,5-8)
    NONE_APPLICABLE      text ranges: [(100,103)]
      PSI: KtNameReferenceExpression at (7,5-8)
  for PSI element of type KtNameReferenceExpression at (8,5-8)
    NONE_APPLICABLE      text ranges: [(115,118)]
      PSI: KtNameReferenceExpression at (8,5-8)

          rangesBuffer.writeByte(range.b2)
          rangesBuffer.writeByte('-'.code)
        }
        is MappedRange.Inline2 -> {
          rangesBuffer.writeByte(range.b1)
          rangesBuffer.writeByte(range.b2)
          rangesBuffer.writeByte(range.b3)
        }
        is MappedRange.InlineDelta -> {
          rangesBuffer.writeByte(range.b1)
          rangesBuffer.writeByte(range.b2)