cmd.SetOut(&out)
			cmd.SetErr(&out)
			cmd.SetArgs(v.args)
			err := cmd.Execute()
			output := out.String()

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

			if v.expectedRegexp != nil && !v.expectedRegexp.MatchString(output) {

	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) {

		diag.MockResource("GrandCastle"),
		"the castle is too old",
	)

	msgs := diag.Messages{firstMsg, secondMsg}
	output, _ := Print(msgs, JSONFormat, false)

	expectedOutput := `[
	{
		"code": "B1",
		"documentationUrl": "` + url.ConfigAnalysis + `/b1/",
		"level": "Error",
		"message": "Explosion accident: the bubble is too big",
		"origin": "SoapBubble"
	},
	{

        and:
        def i386Exe = x86ToolChain.executable(file("build/exe/main/i386/main"))
        assert i386Exe.exec().out == helloWorld.expectedOutput(x86ToolChain)
        def sparcExe = sparcToolChain.executable(file("build/exe/main/sparc/main"))
        assert sparcExe.exec().out == helloWorld.expectedOutput(sparcToolChain)
    }

    def checkInstall(String path, AvailableToolChains.InstalledToolChain toolChain) {

    final SwiftApp main = new SwiftApp()
    final XCTestSourceElement test = new SwiftAppTest(main, main.greeter, main.sum, main.multiply)

    String expectedOutput = main.expectedOutput

    SwiftAppWithXCTest() {
        super('app')
    }

    private final main = new SwiftMain(greeter, sum)

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

        checkEncodeToString("22", "MjI=")
        checkEncodeToString("333", "MzMz")
        checkEncodeToString("4444", "NDQ0NA==")
    }

    private fun checkEncodeToString(input: String, expectedOutput: String) {
        assertEquals(expectedOutput, Base64Factory.createEncoder().encodeToString(input.asciiToByteArray()))
    }

    private fun String.asciiToByteArray() = ByteArray(length) {
        get(it).code.toByte()
    }

        public ExecutionResult assertOutputEquals(String expectedOutput, boolean ignoreExtraLines, boolean ignoreLineOrder) {
            outputResult.assertOutputEquals(expectedOutput, ignoreExtraLines, ignoreLineOrder);
            return this;
        }

        @Override
        public ExecutionResult assertNotOutput(String expectedOutput) {
            outputResult.assertNotOutput(expectedOutput);
            return this;
        }

                }
            }.withTestableImport(main.moduleName)]
        }
    }

    String expectedOutput = main.expectedOutput

    SwiftAppWithSingleXCTestSuite() {
        super('app')
    }

            String getExpectedOutput() {
                return "hi from main\n${greeter.expectedOutput}"
            }
        }
    }

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