var blockSize int64
		if r.AllocObjects > 0 {
			blockSize = r.AllocBytes / r.AllocObjects
		}
		b.pbSample(values, locs, func() {
			if blockSize != 0 {
				b.pbLabel(tagSample_Label, "bytes", "", blockSize)
			}
		})
	}
	b.build()
	return nil
}

// scaleHeapSample adjusts the data from a heap Sample to
// account for its probability of appearing in the collected

            throw new RuntimeException(errorMessageFor("TransformerFactory"), e);
        }
    }

    private static String errorMessageFor(String factory) {
        return "Unable to create secure " + factory + ", please make sure that your build does not depend on an old XML parser.";
    }

    private XmlFactories() {}

            throw e
        }

        then:
        Exception t = thrown()
        (t instanceof UncheckedIOException && t.message == 'Unable to download Maven binary distribution from any of the repositories') ||
            t instanceof AssumptionViolatedException
    }

		switch errs := validation.ValidateTableOptions(opts); len(errs) {
		case 0:
			return opts, nil
		case 1:
			return nil, errors.NewBadRequest(fmt.Sprintf("Unable to convert to Table as requested: %v", errs[0].Error()))
		default:
			return nil, errors.NewBadRequest(fmt.Sprintf("Unable to convert to Table as requested: %v", errs))
		}
	}
	return nil, nil
}

        1 * watcherRegistry.getAndResetStatistics() >> Stub(FileWatcherRegistry.FileWatchingStatistics)
        1 * watcherRegistry.setDebugLoggingEnabled(false)
        0 * _
    }

    def "does not start watching when unable to detect unsupported file systems"() {
        when:
        def result = watchingVirtualFileSystem.afterBuildStarted(WatchMode.DEFAULT, VfsLogging.NORMAL, WatchLogging.NORMAL, buildOperationRunner)
        then:

		RunE: func(cmd *cobra.Command, args []string) error {
			if err := log.Configure(loggingOptions); err != nil {
				log.Errorf("Unable to configure logging: %v", err)
			}

			if cs, err := ctrlz.Run(introspectionOptions, nil); err == nil {
				defer cs.Close()
			} else {
				log.Errorf("Unable to initialize ControlZ: %v", err)
			}

			run(sArgs)
			return nil
		},
	}

	loggingOptions.AttachCobraFlags(serverCmd)

func getContainerIDFromLegacyLogSymlink(logSymlink string) (string, error) {
	parts := strings.Split(logSymlink, "-")
	if len(parts) == 0 {
		return "", fmt.Errorf("unable to find separator in %q", logSymlink)
	}
	containerIDWithSuffix := parts[len(parts)-1]
	suffix := fmt.Sprintf(".%s", legacyLogSuffix)
	if !strings.HasSuffix(containerIDWithSuffix, suffix) {

            String packageFolder = packageName.replaceAll("[.]", "/")
            def className = (body =~ /(?s).*?(?:class|interface|enum|trait) ([\w$]+) .*/)[0][1]
            assert className: "unable to find class name"
            def f
            if (packageFolder.isEmpty()) {
                f = file("$basePath/${className}.$suffix")
            } else {

                    return constructor.newInstance(testClass);
                } catch (Throwable e) {
                    LoggerFactory.getLogger(getClass()).warn("Unable to load JUnit4 runner to calculate Ignored test cases", e);
                }
            }
            return null;
        }
    }

    private static class IgnoredIgnoredBuilder extends IgnoredBuilder {

name: build

on:
  push:
    branches:
      - master
  pull_request:
    types: [opened, labeled, unlabeled, synchronize]

permissions:
  contents: read

env:
  GRADLE_OPTS: "-Dorg.gradle.jvmargs=-Xmx4g -Dorg.gradle.daemon=false -Dkotlin.incremental=false"

jobs:
  publish:
    runs-on: ubuntu-latest
    if: github.repository == 'square/okhttp' && github.ref == 'refs/heads/master'

    steps:
      - name: Checkout