future.addListener(
        new Runnable() {
          @Override
          public void run() {
            latch.countDown();
          }
        },
        exec);

    assertEquals(1, latch.getCount());
    assertFalse(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void tearDown() {
    exec.shutdown();
  }

  public void testCompletedFuture(@Nullable Object expectedValue)

    }

    public void expectCall() {
      assertFalse("expectCall is already true", expectCall);
      expectCall = true;
    }

    public boolean wasCalled() {
      return calledCountDown.getCount() == 0;
    }

    public void waitForCall() throws InterruptedException {
      assertTrue("expectCall is false", expectCall);
      calledCountDown.await();
    }
  }

def artifactType = Attribute.of('artifactType', String)

class Counter implements Serializable {
    private int count = 0;

    public int increment() {
        return ++count;
    }

    public int getCount() {
        return count;
    }
}

class Resolve extends Copy {

    @Internal
    ArtifactCollection artifacts
    @Internal
    final artifactType = Attribute.of('artifactType', String)

        try {
            final Object content = message.getContent();
            if (content instanceof final Multipart multipart) {
                final int count = multipart.getCount();
                for (int i = 0; i < count; i++) {
                    final BodyPart bodyPart = multipart.getBodyPart(i);
                    if (Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition())) {

    @Override
    public void onRemoval(RemovalNotification<K, V> notification) {
      count.incrementAndGet();
      lastNotification = notification;
    }

    public int getCount() {
      return count.get();
    }

    public K getLastEvictedKey() {
      return lastNotification.getKey();
    }

    public V getLastEvictedValue() {
      return lastNotification.getValue();
    }

  ArrayAttr stride = mlir::dyn_cast<ArrayAttr>(identifier_to_attr["strides"]);
  const int stride_h = mlir::cast<IntegerAttr>(stride[1]).getInt();
  const int stride_w = mlir::cast<IntegerAttr>(stride[2]).getInt();
  return rewriter.getI64ArrayAttr({stride_h, stride_w});
}

Attribute GetLhsDilationValue(PatternRewriter& rewriter,

    /**
     * Retrieve an <code>int</code>. If the key does not exist or
     * cannot be converted to an <code>int</code>, the provided default
     * argument will be returned.
     */
    public static int getInt ( Properties props, String key, int def ) {
        String s = props.getProperty(key);
        if ( s != null ) {
            try {
                def = Integer.parseInt(s);
            }

	"istio.io/istio/istioctl/pkg/writer/compare"
)

func createIstiodDumps(f *fuzz.ConsumeFuzzer) (map[string][]byte, error) {
	m := make(map[string][]byte)
	maxNoEntries := 50
	qty, err := f.GetInt()
	if err != nil {
		return m, err
	}
	noOfEntries := qty % maxNoEntries
	if noOfEntries == 0 {
		return m, errors.New("a map of zero-length was created")
	}
	for i := 0; i < noOfEntries; i++ {

  virtual ~AbstractOpAttrs() = default;

  // Returns the AbstractFunction as a FunctionDef.
  virtual void GetNameAttrList(
      tensorflow::NameAttrList* name_and_attrs) const = 0;

  virtual bool GetInt(absl::string_view, int64_t* result) const = 0;
  virtual bool GetFloat(absl::string_view attr_name, float* result) const = 0;
  virtual bool GetBool(absl::string_view attr_name, bool* result) const = 0;

 */

package jcifs.smb1.smb1;

import jcifs.smb1.Config;

public class BufferCache {

    private static final int MAX_BUFFERS = Config.getInt( "jcifs.smb1.smb.maxBuffers", 16 );

    static Object[] cache = new Object[MAX_BUFFERS];
    private static int freeBuffers = 0;

    static public byte[] getBuffer() {
        synchronized( cache ) {