cmd.SilenceUsage = true
	cmd.SetOut(&out)
	cmd.SetErr(&out)

	fErr := cmd.Execute()
	output := out.String()

	if c.expectedOutput != "" && c.expectedOutput != output {
		t.Fatalf("Unexpected output for 'istioctl %s'\n got: %q\nwant: %q", strings.Join(c.args, " "), output, c.expectedOutput)
	}

	if c.expectedString != "" && !strings.Contains(output, c.expectedString) {

            ":app:compileDebugSwift", ":app:linkDebug", ":app:installDebug", ":app:assemble")

        installation("app/build/install/main/debug").exec().out == app.expectedOutput

        where:
        linkage << [SHARED, STATIC]
    }

    @ToBeFixedForConfigurationCache
    def "can compile and link against a c++ library with both static and shared linkages"() {

    final main = new IncrementalSwiftAppWithDep(lib)

    IncrementalSwiftAppWithDep getApplication() {
        return main
    }

    String getExpectedOutput() {
        return main.expectedOutput
    }

    IncrementalSwiftLib getLibrary() {
        return lib
    }

    class IncrementalSwiftLib extends IncrementalSwiftElement {
        final greeter = new SwiftGreeter()

func TestAuthz(t *testing.T) {
	cases := []testutil.TestCase{
		{
			Args:           []string{"-f fake.yaml"},
			ExpectedOutput: "Error: failed to get config dump from file  fake.yaml: open  fake.yaml: no such file or directory\n",
			WantException:  true,
		},
		{
			Args: []string{"-f", "testdata/configdump.yaml"},
			ExpectedOutput: `ACTION   AuthorizationPolicy         RULES
ALLOW    _anonymous_match_nothing_   1

  }

  private static void testReverse(char[] input, char[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Chars.reverse(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

  private static void testReverse(char[] input, int fromIndex, int toIndex, char[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Chars.reverse(input, fromIndex, toIndex);

    Summary summary;
    ASSERT_TRUE(ParseProtoUnlimited(
        &summary, ctx.mutable_output(0)->scalar<tstring>()()));
    ExpectSummaryMatches(summary, expected_output);
  } else {
    EXPECT_TRUE(absl::StrContains(ctx.status().ToString(), expected_output))
        << ctx.status();
  }
}

TEST(ScalarSummaryOpTest, SimpleFloat) {
  int vectorSize = 3;
  Tensor tags(DT_STRING, {vectorSize});

    }
    """)

    @Override
    String getExpectedOutput() {
        return greeter.expectedOutput
    }

    AppElement withFeatureEnabled() {
        return new AppElement() {
            @Override
            String getExpectedOutput() {
                return "hi from main\n" + greeter.expectedOutput
            }
        }
    }

    private final main = new CppMain(greeter, sum)

    final List<IncrementalElement.Transform> incrementalChanges = [
        delete(greeter), delete(sum), delete(main)]
    final String expectedOutput = main.expectedOutput

    final SwiftSum sum = new SwiftSum()
    final SwiftMultiply multiply = new SwiftMultiply()
    final XCTestSourceElement test = new SwiftAppTest(main, app.greeter, sum, multiply)

    String expectedOutput = main.expectedOutput

    SwiftAppWithLibrariesAndXCTest() {
        super('app')
    }

    SourceElement getGreeter() {
        return app.greeter
    }

    SourceElement getLogger() {

    final main = new IncrementalCppAppWithDep(lib)

    IncrementalCppAppWithDep getExecutable() {
        return main
    }

    String getExpectedOutput() {
        return main.expectedOutput
    }

    IncrementalCppLib getLibrary() {
        return lib
    }

    class IncrementalCppLib extends IncrementalCppElement {
        final greeter = new CppGreeter()
        final sum = new CppSum()