assertEquals("message", record.getMessage());
    assertSame(EXCEPTION, record.getThrown());
  }

  public void testConcurrentModification() throws Exception {
    // Tests for the absence of a bug where logging while iterating over the
    // stored log records causes a ConcurrentModificationException
    assertTrue(handler.getStoredLogRecords().isEmpty());
    ExampleClassUnderTest.foo();

     * In this case, the failure can be synthetic to provide the stack trace for the problem origin.
     * <p>
     * The failure can also be omitted due to limits. Its absence does not mean there was no exception causing the problem.
     */
    @Nullable
    Failure getFailure();

    /**
     * Returns an exception that can be thrown when this problem should result in an error.
     *

 * This approach ensures that sharing mutable state across targets via any means
 * (including {@link org.gradle.api.services.BuildService}, which are not supported) is prevented.
 * The absence of shared mutable state allows these actions to be safely executed in parallel as needed.
 *
 * <p><b>IMPORTANT:</b> As isolated action instances are recreated using Configuration Cache serialization, they must

	"runtime"
	"strings"
)

// testProg creates a package called name, with path dir/name.go,
// which declares an untyped constant of the given length.
// testProg compiles this package and checks for the absence or
// presence of a constant literal error.
func testProg(dir, name string, length int, msg string) {
	var buf bytes.Buffer

	fmt.Fprintf(&buf,
		"package %s; const _ = 0b%s // %d bits",

 * <p>Caching for individual task instances can be enabled and disabled via {@link TaskOutputs#cacheIf(String, Spec)} or disabled via {@link TaskOutputs#doNotCacheIf(String, Spec)}.
 * Using these APIs takes precedence over the presence (or absence) of {@code @DisableCachingByDefault}.</p>
 *
 * @see org.gradle.api.tasks.CacheableTask
 * @see org.gradle.api.artifacts.transform.CacheableTransform
 *
 * @since 7.0
 */
@Documented

        return get(key);
    }

    @Override
    public CachedMetadata cacheMissing(ModuleComponentRepository<?> repository, ModuleComponentIdentifier id) {
        LOGGER.debug("Recording absence of module descriptor in cache: {} [changing = {}]", id, false);
        ModuleComponentAtRepositoryKey key = createKey(repository, id);

	}
	str := (*in)[0]
	i, err := strconv.Atoi(str)
	if err != nil {
		return err
	}
	*out = i
	return nil
}

// Convert_Slice_string_To_bool will convert a string parameter to boolean.
// Only the absence of a value (i.e. zero-length slice), a value of "false", or a
// value of "0" resolve to false.
// Any other value (including empty string) resolves to true.

type PodDisruptionBudgetSpec struct {
	// An eviction is allowed if at least "minAvailable" pods selected by
	// "selector" will still be available after the eviction, i.e. even in the
	// absence of the evicted pod.  So for example you can prevent all voluntary
	// evictions by specifying "100%".
	// +optional
	MinAvailable *intstr.IntOrString

	// Label query over pods whose evictions are managed by the disruption

//
//   - Hostname is the hostname of the local machine (from uname -n).
//     However, some components allow the user to pass in a --hostname-override flag,
//     which will override this in most places. In the absence of anything more meaningful,
//     kubelet will use Hostname as the Node.Name when it creates the Node.
//
// * The cloudproviders have the own names: GCE has InstanceName, AWS has InstanceId.
//

	}

	ctx, cancel := context.WithTimeout(context.Background(), csiTimeout)
	defer cancel()

	csiClient, err := m.csiClientGetter.Get()
	if err != nil {
		// Treat the absence of the CSI driver as a transient error
		// See https://github.com/kubernetes/kubernetes/issues/120268
		return "", volumetypes.NewTransientOperationFailure(log("blockMapper.SetUpDevice failed to get CSI client: %v", err))
	}