return Platform.newArray(reference, length);
  }

  /**
   * Returns a new array that contains the concatenated contents of two arrays.
   *
   * @param first the first array of elements to concatenate
   * @param second the second array of elements to concatenate
   * @param type the component type of the returned array
   */
  @GwtIncompatible // Array.newInstance(Class, int)

  func.return %0 : tensor<6x3xf32>
}
}

// CHECK:       module {
// CHECK-NEXT:  func @main(%arg0: tensor<3x3xf32>, %arg1: tensor<3x3xf32>) -> tensor<6x3xf32> {

		Bits += b.Bits
	}
	return u, Bits
}

// Parse extracts the bitfields from i, concatenate them and return the result
// as an unsigned integer. Parse will panic if any bitfield in b is invalid.
func (bs BitFields) Parse(i [2]uint32) uint64 {
	u, _ := bs.parse(i)
	return u
}

// ParseSigned extracts the bitfields from i, concatenate them and return the result
// as a signed integer. Parse will panic if any bitfield in b is invalid.

        union.getAttribute(BAR) == 'bar'
    }

    def "can concatenate attribute to an empty set"() {
        when:
        def set = factory.concat(factory.root, FOO, "foo")

        then:
        set.keySet() == [FOO] as Set

        and:
        set.getAttribute(FOO) == 'foo'
    }

    def "can concatenate attribute to a singleton set"() {
        when:

[!exec:false] skip

exec echo foo
stdout foo

exec echo foo &
exec echo bar &
! exec false &

# Starting a background process should clear previous output.
! stdout foo

# Wait should set the output to the concatenated outputs of the background
# programs, in the order in which they were started.
wait
stdout 'foo\nbar'

# The end of the test should interrupt or kill any remaining background

// license that can be found in the LICENSE file.

package cgotest

// Test that we have no more than one build ID.  In the past we used
// to generate a separate build ID for each package using cgo, and the
// linker concatenated them all.  We don't want that--we only want
// one.

import (
	"bytes"
	"debug/elf"
	"os"
	"testing"
)

func testBuildID(t *testing.T) {
	f, err := elf.Open("/proc/self/exe")
	if err != nil {

warning output from the go api tool. Each file should be named
nnnnn.txt, after the issue number for the accepted proposal.
(The #nnnnn suffix must also appear at the end of each line in the file;
that will be preserved when next/*.txt is concatenated into go1.XX.txt.)

When you add a file to the api/next directory, you must add at least one file

// In the second, only p is live, so that bitmap is 10.
// Bitmaps are byte aligned, so if the first bitmap is interpreted as
// extending across the entire argument area, we incorrectly concatenate
// the bitmaps and end up using 110000001. That bad bitmap causes a6
// to be considered a pointer.
func noPointerArgs(p, q *byte, a0, a1, a2, a3, a4, a5, a6 uintptr) {
	sink = make([]byte, 4096)
	sinkptr = q

		1  .  X: 42
		2  }`},
	{struct{ X, Y int }{42, 991},
		`0  struct { X int; Y int } {
		1  .  X: 42
		2  .  Y: 991
		3  }`},
}

// Split s into lines, trim whitespace from all lines, and return
// the concatenated non-empty lines.
func trim(s string) string {
	lines := strings.Split(s, "\n")
	i := 0
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line != "" {
			lines[i] = line
			i++
		}
	}

        then:
        DaemonExpirationResult result = agg.checkExpiration()
        result.status == DO_NOT_EXPIRE
        result.reason == null
    }

    def "doesn't concatenate a null reason"() {
        given:
        AllDaemonExpirationStrategy agg = new AllDaemonExpirationStrategy([c1, c2])

        when:
        1 * c1.checkExpiration() >> { new DaemonExpirationResult(GRACEFUL_EXPIRE, null) }