compositeSubstitute()
                configuration = "runtimeElements"
            }
            module("org.test:b2:1.0")
        }
    }

    def "can combine included builds with declared and discovered substitutions"() {
        given:
        dependency "org.test:b1:1.0"
        dependency "org.test:XXX:1.0"

        includeBuild buildB
        includeBuild buildC, """

        assertTestExecuted(className: 'example2.MyOtherTest', methodName: 'bar', task: ':secondTest')
        assertTestExecuted(className: 'example2.MyOtherTest2', methodName: 'baz', task: ':secondTest')
    }

    def "can combine different test selection"() {
        setup:
        file('src/test/java/org/AnotherTest.java').text = '''
            package org;
            public class AnotherTest {

                        log.debug("Next referral is " + next);
                    }
                    if ( res == null ) {
                        res = r.combine(next);
                    }
                    else {
                        res.append(r.combine(next));
                    }
                }
                while ( next != nextstart );
            }
        }
        while ( r != start );

        result.testClass("MixedTests").assertTestsExecuted('tagAOk1')
        result.testClass("MixedTests").assertTestsSkipped('ignoredWithTagA')
    }

    def "can combine tags with custom extension"() {
        given:
        testSources.with {
            sourceFile("Locales.java").withSource("""
                import org.junit.jupiter.api.extension.Extension;

				continue
			}

			for n := f.Config.RegSize / size; n > 1; n /= 2 {
				if combineStores(v, n) {
					continue
				}
			}
		}
	}
}

// Try to combine the n stores ending in root.
// Returns true if successful.
func combineStores(root *Value, n int64) bool {
	// Helper functions.
	type StoreRecord struct {
		store  *Value
		offset int64
	}

        if (hiChars == null && loChars == null) {
          // We expect this to be the common code path for most escapers.
          return null;
        }
        // Combine the characters and/or escaped sequences into a single array.
        int hiCount = hiChars != null ? hiChars.length : 1;
        int loCount = loChars != null ? loChars.length : 1;

        putAll(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    Builder<K, V> combine(ImmutableMultimap.Builder<K, V> other) {
      super.combine(other);
      return this;
    }

    /**
     * {@inheritDoc}
     *
     * @since 8.0
     */
    @CanIgnoreReturnValue
    @Override

        result.testClass("MixedTests").assertTestsExecuted('catAOk1', 'catBOk2')
        result.testClass("MixedTests").assertTestsSkipped('ignoredWithCategoryA')
    }

    def "can combine categories with custom runner"() {
        given:
        testSources.with {
            testCategory('CategoryA')
            sourceFile('LocaleHolder.java').withSource("""
                import java.util.Locale;

                                                /*transpose_a=*/op.getAdjX(),
                                                /*transpose_b=*/op.getAdjY());
    matmuls.emplace_back(matmul.getProduct());
  }

  // Combine the result of each individual MatMul into a rank-3 tensor.
  Type packed_type = RankedTensorType::get(
      {bcast.output_batch_size(), rows, cols}, element_type);
  const auto axis = rewriter.getI64IntegerAttr(0);

	if *verbflag >= 3 {
		fmt.Printf("visit pk=%d fid=%d func %s\n", pkgIdx, fnIdx, fd.Funcname)
	}

	var counters []uint32
	key := pkfunc{pk: pkgIdx, fcn: fnIdx}
	v, haveCounters := mm.pod.pmm[key]
	if haveCounters {
		counters = v.Counters
	}

	if pcombine {
		// If the merge is running in "combine programs" mode, then hash