not once.  This is consistent with (a*)* matching a, which
    runs the starred subexpression one time, not twice.
  * The submatch choice is first match, not the POSIX rule.

Such changes are marked with 'RE2/Go'.


RE2 Test Files

re2-exhaustive.txt.bz2 and re2-search.txt are built by running
'make log' in the RE2 distribution https://github.com/google/re2/

/*
typedef void *HANDLE;

struct HWND__{int unused;}; typedef struct HWND__ *HWND;
*/
import "C"

import (
	"testing"
	"unsafe"
)

func test42018(t *testing.T) {
	// Test that Windows handles are marked go:notinheap, by growing the
	// stack and checking for pointer adjustments. Trick from
	// test/fixedbugs/issue40954.go.
	var i int
	handle := C.HANDLE(unsafe.Pointer(uintptr(unsafe.Pointer(&i))))

go list all # make sure the consistency checks pass
! stderr .

# Removing the replace causes consistency checks to fail
cp a_go_mod_no_replace a/go.mod
! go list all # consistency checks fail
stderr 'example.com/b@v0.0.0: is marked as replaced in vendor/modules.txt, but not replaced in the workspace'


-- a_go_mod_no_replace --
module example.com/a

go 1.21

require example.com/b v0.0.0
-- go.work --
go 1.21

use (
    a

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

// An optimization pass that groups nodes marked with a common
// kXlaClusterAttr into functions, and replaces the original nodes by
// calls. The calls are annotated with kXlaCompiledKernelAttr.

#ifndef TENSORFLOW_COMPILER_JIT_ENCAPSULATE_SUBGRAPHS_PASS_H_

LogicalResult MarkUncompilableOps(
    const Dialect* tf_dialect, Block* block,
    llvm::DenseSet<OperationName>& supported_ops) {
  // Automatically marked ops for outside compilation have
  // `_xla_outside_compilation` attribute value of "auto" plus
  // an increasing counter.  Manually marked ops for outside compilation only
  // have an increasing counteri for the attribute value.  Therefore there is no
  // collision in

    int dynCount = 1

    def 'empty by default'() {
        expect:
        verifyEmpty(selectors)
    }

    def 'can add a selector not marked as deferring'() {
        given:
        def selector = Mock(ResolvableSelectorState)

        when:
        selectors.add(selector, false)

        then:
        selectors.size() == 1

      ACTIONS_STEP_DEBUG: true
    steps:
    - name: Close Stale Issues
      uses: actions/stale@v8
      with:
        repo-token: ${{ secrets.GITHUB_TOKEN }}

 */

package com.google.common.hash;

import com.google.common.base.Supplier;
import com.google.errorprone.annotations.Immutable;

/**
 * Explicitly named subinterface of {@link Supplier} that can be marked {@literal @}{@link
 * Immutable}.
 */
// TODO(cpovirk): Should we just use ChecksumType directly instead of defining this type?
@Immutable
@ElementTypesAreNonnullByDefault

 */

package com.google.common.hash;

import com.google.common.base.Supplier;
import com.google.errorprone.annotations.Immutable;

/**
 * Explicitly named subinterface of {@link Supplier} that can be marked {@literal @}{@link
 * Immutable}.
 */
// TODO(cpovirk): Should we just use ChecksumType directly instead of defining this type?
@Immutable
@ElementTypesAreNonnullByDefault

	started := make(chan struct{})
	unblock := make(chan struct{})
	q.Add(func() {
		close(started)
		<-unblock
	})

	<-started
	idle := q.Idle()
	select {
	case <-idle:
		t.Errorf("NewQueue(1) is marked idle while processing work.")
	default:
	}

	close(unblock)
	<-idle // Should be closed as soon as the Add callback returns.
}

func TestQueueBacklog(t *testing.T) {
	const (
		maxActive = 2