# with regex '.*invalid_function_name.*' did not match the quantizable unit.
    self.assertAllClose(new_outputs, expected_outputs, rtol=0.04)
    self.assertNotAllClose(new_outputs, expected_outputs, 1e-7)

    # Due to other meta data, the compression is not exactly 1/4.
    self.assertLess(
        testing.get_size_ratio(

    self.assertCountEqual(
        converted_model.signatures._signatures.keys(), {signature_key}
    )

    expected_outputs = model.matmul(**model_inputs)
    got_outputs = converted_model.signatures[signature_key](**model_inputs)
    self.assertAllClose(expected_outputs, got_outputs, atol=1e-1)

    output_loader = saved_model_loader.SavedModelLoader(
        self._output_saved_model_path
    )

    private static final String EXPECTED_OUTPUT = "Hello, World!"
    private static final String EXPECTED_ERROR = "Goodbye, World!"

    @UnsupportedWithConfigurationCache(because = "Task.getProject() during execution")
    def "Project.javaexec output is grouped with its task output"() {
        given:
        generateMainJavaFileEchoing(EXPECTED_OUTPUT, EXPECTED_ERROR)
        buildFile << """

    public ExecutionResult assertHasErrorOutput(String expectedOutput) {
        assertContentContains(getOutput(), expectedOutput, "Build output");
        return this;
    }

    @Override
    public boolean hasErrorOutput(String expectedOutput) {
        return getOutput().contains(expectedOutput);
    }

    @Override
    public ExecutionResult assertOutputEquals(String expectedOutput, boolean ignoreExtraLines, boolean ignoreLineOrder) {

func TestFlagsToInt(t *testing.T) {

	tests := []struct {
		name           string
		input          []string
		expectedOutput int
	}{
		{
			name:           "nil input",
			input:          nil,
			expectedOutput: 0,
		},
		{
			name:           "no flags",
			input:          []string{},
			expectedOutput: 0,
		},
		{
			name: "all flags",
			input: []string{
				kubeadmapi.UnmountFlagMNTForce,

     *
     * @param expectedOutput The expected log message, with line endings normalized to a newline character.
     */
    boolean hasErrorOutput(String expectedOutput);

    ExecutionResult assertOutputEquals(String expectedOutput, boolean ignoreExtraLines, boolean ignoreLineOrder);

    /**

        releaseBinary.assertExists()
        releaseBinary.exec().out == app.withFeatureEnabled().expectedOutput
        installation("build/install/main/release").exec().out == app.withFeatureEnabled().expectedOutput
        releaseBinary.assertHasStrippedDebugSymbolsFor(['main.o', 'greeter.o'])

        succeeds "assembleDebug"

    }

    @Override
    public boolean hasErrorOutput(String expectedOutput) {
        return getError().contains(expectedOutput);
    }

    @Override
    public ExecutionResult assertHasErrorOutput(String expectedOutput) {
        return assertContentContains(errorContent.withNormalizedEol(), expectedOutput, "Error output");
    }

    @Override
    public String getError() {

        runWork()

        then: 'it runs as expected'
        outputContains expectedOutput

        when: 'task runs for the 2nd time'
        runWork()

        then: 'it is skipped because UP-TO-DATE'
        result.assertTaskSkipped ':runWork'
        outputContains ':runWork UP-TO-DATE'

        and:
        outputDoesNotContain expectedOutput

        when: 'the outputs are deleted'
        file('build').deleteDir()

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