if len(subs) == 0 {
		return p.push(p.newRegexp(OpEmptyMatch))
	}

	return p.push(p.collapse(subs, OpConcat))
}

// alternate replaces the top of the stack (above the topmost '(') with its alternation.
func (p *parser) alternate() *Regexp {
	// Scan down to find pseudo-operator (.
	// There are no | above (.
	i := len(p.stack)
	for i > 0 && p.stack[i-1].Op < opPseudo {
		i--
	}

		}
		if len(item.alternate) == 0 {
			continue
		}
		q, err = ParseQuantity(item.alternate)
		if err != nil {
			t.Errorf("%#v: unexpected error: %v", item.expect, err)
			continue
		}
		if len(q.s) != 0 {
			t.Errorf("%#v: unexpected nested string: %v", item.expect, q.s)
		}
		if q.String() != item.expect {
			t.Errorf("%#v: unexpected alternate canonical: %v", item.expect, q.String())
		}

        supplierInteractions = withPerVersionStatusSupplier(metadataFile, true, "println 'Alternate implementation'")
        run 'checkDeps'

        then:
        outputContains("Providing metadata for group:projectB:2.2")
        outputContains("Providing metadata for group:projectB:1.1")
        outputContains("Alternate implementation")

    }

    @ToBeFixedForConfigurationCache

        assertValueIs(['2', '3d', '4', '5', '6'], property3)
    }

    def "can alternate append and add"() {
        when:
        property.append("1")
        property.add("2")
        property.append("3")

        then:
        assertValueIs toImmutable(["1", "2", "3"])
    }

    def "can alternate add and append"() {
        when:
        property.add("1")
        property.append("2")

	}
	tr.mu.Unlock()
}

// useRegisteredProtocol reports whether an alternate protocol (as registered
// with Transport.RegisterProtocol) should be respected for this request.
func (t *Transport) useRegisteredProtocol(req *Request) bool {
	if req.URL.Scheme == "https" && req.requiresHTTP1() {
		// If this request requires HTTP/1, don't use the
		// "https" alternate protocol, which is used by the

        1 * transform.transform(_)
    }

    def "can alternate insert and put"() {
        when:
        property.insert("k1", "1")
        property.put("k2", "2")
        property.insert("k3", "3")
        property.put("k2", "4")

        then:
        assertValueIs(['k1': '1', 'k2': '4', 'k3': '3'])
    }

    def "can alternate put and insert"() {
        when:

	"retryAfterSeconds": "If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action.",
}

func (StatusDetails) SwaggerDoc() map[string]string {
	return map_StatusDetails
}

var map_Table = map[string]string{

  repeated StatusCause causes = 4;

  // If specified, the time in seconds before the operation should be retried. Some errors may indicate
  // the client must take an alternate action - for those errors this field may indicate how long to wait
  // before taking the alternate action.
  // +optional
  optional int32 retryAfterSeconds = 5;
}

// TableOptions are used when a Table is requested by the caller.

  repeated StatusCause causes = 4;

  // If specified, the time in seconds before the operation should be retried. Some errors may indicate
  // the client must take an alternate action - for those errors this field may indicate how long to wait
  // before taking the alternate action.
  // +optional
  optional int32 retryAfterSeconds = 5;
}

// TableOptions are used when a Table is requested by the caller.

  string DebugStringForCyclesGraphNode(int node_id, bool* found_unclustered);

  // We could not contract the edge from `from` to `to`.  Return a string
  // describing an alternate path from `from` to `to` (besides the direct edge
  // from `from` to `to`) which would have created a cycle had we contracted the
  // edge.
  //