if err == nil {
		log.Fatalf("Passed, expected an error")
	}

	want := []byte("fatal error: all goroutines are asleep - deadlock!")
	if !bytes.Contains(output, want) {
		log.Fatalf("Unmatched error message %q:\nin\n%s\nError: %v", want, output, err)
	}

		{
			fprintf(stdout, "pause.c %s\n", VERSION_STRING(VERSION));
			return 0;
		}
	}

	if (SetConsoleCtrlHandler(CtrlHandler, TRUE))
	{
		Sleep(INFINITE);
	}
	else
	{
		printf("\nERROR: Could not set control handler\n");
		return 1;
	}
	return 0;

					if err == io.EOF {
						break
					}
					t.Fatalf("couldn't read converted event: %s", err)
				}
				if err := v.Event(ev); err != nil {
					t.Fatalf("converted event did not validate; event: \n%s\nerror: %s", ev, err)
				}

				if testName == "user_task_region_1_21_good" {
					testedUserRegions = true
					validRegions := map[string]struct{}{
						"post-existing region": struct{}{},

	if err != nil {
		return fmt.Errorf("iscsi: failed to detach disk: %s\nError: %v", deviceMountPath, err)
	}
	klog.V(4).Infof("iscsi: %q is unmounted, deleting the directory", deviceMountPath)
	err = os.RemoveAll(deviceMountPath)
	if err != nil {
		return fmt.Errorf("iscsi: failed to delete the directory: %s\nError: %v", deviceMountPath, err)
	}

	if err != nil {
		klog.Errorf("fc: failed to get device from mnt: %s\nError: %v", deviceMountPath, err)
		return err
	}
	// Unmount for deviceMountPath(=globalPDPath)
	err = mount.CleanupMountPoint(deviceMountPath, detacher.mounter, false)
	if err != nil {
		return fmt.Errorf("fc: failed to unmount: %s\nError: %v", deviceMountPath, err)
	}

	if err == nil {
		log.Fatalf("Passed, expected an error")
	}

	want := []byte("nil pointer dereference")
	if !bytes.Contains(output, want) {
		log.Fatalf("Unmatched error message %q:\nin\n%s\nError: %v", want, output, err)
	}

	}()
	panic(P("XXX"))
}

// Test that panic while panicking discards error message
// See issue 52257
type exampleError struct{}

func (e exampleError) Error() string {
	panic("important multi-line\nerror message")
}

func ErrorPanic() {
	panic(exampleError{})
}

type examplePanicError struct{}

func (e examplePanicError) Error() string {
	panic(exampleError{})
}

func DoubleErrorPanic() {

	}

	if len(entry.Trace.Variables) > 0 {
		tagString = "\n       " + tagString
	}

	msg := color.RedBold(entry.Trace.Message)
	output := fmt.Sprintf("\n%s\n%s%s%s%s%s%s\nError: %s%s\n%s",
		apiString, timeString, deploymentID, requestID, remoteHost, host, userAgent,
		msg, tagString, strings.Join(trace, "\n"))

	fmt.Fprintln(c.output, output)
	return nil
}

			} else {
				dataDir, err = getEtcdDataDir(manifestPath, nil)
			}

			if (err != nil) != test.expectErr {
				t.Fatalf(dedent.Dedent(
					"getEtcdDataDir failed\n%s\nexpected error: %t\n\tgot: %t\nerror: %v"),
					name,
					test.expectErr,
					(err != nil),
					err,
				)
			}

			if dataDir != test.dataDir {

    return 0;
  }
  bool parsed_flags_ok = tensorflow::Flags::Parse(&argc, argv, flag_list);
  QCHECK(parsed_flags_ok) << "\n" << usage;

  tensorflow::port::InitMain(usage.c_str(), &argc, &argv);
  QCHECK(argc == 1) << "\nERROR: This command does not take any arguments "
                       "other than flags. See --help.\n\n";
  tensorflow::Status status = tensorflow::tfcompile::Main(flags);
  if (status.code() == absl::StatusCode::kInvalidArgument) {