z = &t.x[i]
		*z = 2
	}
}

// Issue 15730: copy causes unnecessary escape

var sink []byte
var sink2 []int
var sink3 []*int

func f15730a(args ...interface{}) { // ERROR "args does not escape"
	for _, arg := range args {
		switch a := arg.(type) {
		case string:
			copy(sink, a)
		}
	}
}

func f15730b(args ...interface{}) { // ERROR "args does not escape"

	})

	shouldPanic(func() {
		var a [3]int
		sinkS = a /*line :999999:1*/ [ /*line :1100:1*/ i:]
	})
	shouldPanic(func() {
		var a []int
		sinkS = a /*line :999999:1*/ [ /*line :1200:1*/ i:]
	})
	shouldPanic(func() {
		var a [3]int
		sinkS = a /*line :999999:1*/ [: /*line :1300:1*/ i]
	})
	shouldPanic(func() {
		var a []int
		sinkS = a /*line :999999:1*/ [: /*line :1400:1*/ i]
	})

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "C"

var sink []byte

//export GoFunction7
func GoFunction7() {
	sink = make([]byte, 4096)
}

func main() {

		for i := 0; i < b.N; i++ {
			sink32, sink32, sink32, sink32 = c.RGBA()
		}
	})
	b.Run("128", func(b *testing.B) {
		c := YCbCr{128, 128, 128}
		for i := 0; i < b.N; i++ {
			sink32, sink32, sink32, sink32 = c.RGBA()
		}
	})
	b.Run("255", func(b *testing.B) {
		c := YCbCr{255, 255, 255}
		for i := 0; i < b.N; i++ {
			sink32, sink32, sink32, sink32 = c.RGBA()
		}
	})
}

    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

  public void testInt() {
    Sink sink = new Sink(4);
    sink.putInt(0x04030201);
    HashCode unused = sink.hash();
    sink.assertInvariants(4);
    sink.assertBytes(new byte[] {1, 2, 3, 4});
  }

	testMultiWriter(t, struct {
		Writer
		fmt.Stringer
	}{sink, sink})
}

func TestMultiWriter_String(t *testing.T) {
	testMultiWriter(t, new(bytes.Buffer))
}

// Test that a multiWriter.WriteString calls results in at most 1 allocation,
// even if multiple targets don't support WriteString.
func TestMultiWriter_WriteStringSingleAlloc(t *testing.T) {
	var sink1, sink2 bytes.Buffer

        long value = random.nextLong();
        for (PrimitiveSink sink : sinks) {
          sink.putLong(value);
        }
      }
    },
    PUT_FLOAT() {
      @Override
      void performAction(Random random, Iterable<? extends PrimitiveSink> sinks) {
        float value = random.nextFloat();
        for (PrimitiveSink sink : sinks) {
          sink.putFloat(value);
        }
      }
    },

    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

  public void testInt() {
    Sink sink = new Sink(4);
    sink.putInt(0x04030201);
    HashCode unused = sink.hash();
    sink.assertInvariants(4);
    sink.assertBytes(new byte[] {1, 2, 3, 4});
  }

Russ Cox <******@****.***> 1649017006 -0400

 * A test factory for byte or char sources or sinks. In addition to creating sources or sinks, the
 * factory specifies what content should be expected to be read from a source or contained in a sink
 * given the content data that was used to create the source or that was written to the sink.
 *
 * <p>A single {@code SourceSinkFactory} implementation generally corresponds to one specific way of