public void addChain(final AuthenticationChain chain) {
        chains = ArrayUtils.addAll(chains, chain);
    }

    protected StreamOf<AuthenticationChain> chains() {
        return stream(chains);
    }

 * to a root producer variant.
 */
public class TransformedVariant implements HasAttributes {
    private final ResolvedVariant root;
    private final VariantDefinition chain;

    public TransformedVariant(ResolvedVariant root, VariantDefinition chain) {
        this.root = root;
        this.chain = chain;
    }

    /**

	tx.Add(&knftables.Table{})
	tx.Add(&knftables.Chain{
		Name: "mark-masq-chain",
	})
	tx.Add(&knftables.Chain{
		Name: "masquerade-chain",
	})
	tx.Add(&knftables.Chain{
		Name: "empty-chain",
	})

	tx.Add(&knftables.Rule{
		Chain: "mark-masq-chain",
		Rule:  "mark set mark or 0x4000",
	})

	tx.Add(&knftables.Rule{
		Chain: "masquerade-chain",
		Rule:  "mark and 0x4000 == 0 return",
	})

                            module("org:${chain[3]}:1.0") {
                                module "org:${chain[3]}-api-dependency:1.0"
                                if (RepositoryInteractionDependencyResolveIntegrationTest.leaksRuntime(testVariant, chain[3], chain[2])) { module "org:${chain[3]}-runtime-dependency:1.0" }
                            }
                        }

		}
	}

	chain := [][]*Certificate{{}}
	numCerts := macOS.SecTrustGetCertificateCount(trustObj)
	for i := 0; i < numCerts; i++ {
		certRef, err := macOS.SecTrustGetCertificateAtIndex(trustObj, i)
		if err != nil {
			return nil, err
		}
		cert, err := exportCertificate(certRef)
		if err != nil {
			return nil, err
		}
		chain[0] = append(chain[0], cert)
	}
	if len(chain[0]) == 0 {

  let summary = "eager context initialization operation";
  let description = [{
    The "tfd.init_eager_context" operation takes an input chain, creates and
    initializes the TF EagerContext and returns an output chain.

    Example:
      %c1 = "tfd.init_eager_context"(%c0): (!tfrt.chain) -> !tfrt.chain
  }];

  let arguments = (ins TFRT_ChainType);
  let results = (outs TFRT_ChainType);
}

  - Tool chain 'clang' (Clang):
      - Could not find C++ compiler 'clang++'. Searched in:
          - ${file('clang-bin')}""")
        } else {
            failure.assertHasCause("""No tool chain is available to build C++ for host operating system '${osName}' architecture '${archName}':
  - Tool chain 'visualCpp' (Visual Studio):
      - Visual Studio is not available on this operating system.
  - Tool chain 'gcc' (GNU GCC):

  /**
   * Returns a cleaned chain for [chain].
   *
   * This method throws if the complete chain to a trusted CA certificate cannot be constructed.
   * This is unexpected unless the trust root index in this class has a different trust manager than
   * what was used to establish [chain].
   */
  @Throws(SSLPeerUnverifiedException::class)
  override fun clean(
    chain: List<Certificate>,
    hostname: String,

  // CHECK-NEXT: [[out_ch:%.*]] = tfrt.merge.chains [[ch]], [[ch1]] : !tfrt.chain, !tfrt.chain
  // CHECK-NEXT: tfrt.return [[out_ch]], [[r2]] : !tfrt.chain, !tfrt_fallback.tf_tensor
  func.return %6#0 : tensor<3x3xf32>
}

				//   <no matches>
				//   fallback (dest ip):
				//     1.2.3.4: chain
				fallback := NewDestinationIP()
				fallback.Map["1.2.3.4"] = ToChain("chain")

				root := NewDestinationPort()
				root.OnNoMatch = ToMatcher(fallback.Matcher)
				return root
			},
			want: func() *matcher.Matcher {
				// root (dest ip):
				//   1.2.3.4: chain

				// fallback becomes root
				want := NewDestinationIP()