// If it won't fit in a long, then we store off the intermediate product.
      if (normalizedBits + productBits >= Long.SIZE) {
        bignums.add(BigInteger.valueOf(product));
        product = 1;
        productBits = 0;
      }
      product *= normalizedNum;
      productBits = LongMath.log2(product, FLOOR) + 1;
    }
    // Check for leftovers.
    if (product > 1) {
      bignums.add(BigInteger.valueOf(product));
    }

append(b, dk.h[:]...) b = append(b, dk.z[:]...) return b } // EncapsulationKey returns the public encapsulation key necessary to produce // ciphertexts. func (dk *DecapsulationKey1024) EncapsulationKey() *EncapsulationKey1024 { return &EncapsulationKey1024{ ρ: dk.ρ, h: dk.h, encryptionKey1024: dk.encryptionKey1024, } } // An EncapsulationKey1024 is the public key used to produce ciphertexts to be // decapsulated by the corresponding [DecapsulationKey1024]. type EncapsulationKey1024 struct { ρ [32]byte...

        A result(Collector<T, A, R> collector, Iterable<T> inputs);
  }

  /**
   * Verifies that the specified expected result is always produced by collecting the specified
   * inputs, regardless of how the elements are divided.
   */
  @SafeVarargs
  @CanIgnoreReturnValue

append(b, dk.h[:]...) b = append(b, dk.z[:]...) return b } // EncapsulationKey returns the public encapsulation key necessary to produce // ciphertexts. func (dk *DecapsulationKey1024) EncapsulationKey() *EncapsulationKey1024 { return &EncapsulationKey1024{ ρ: dk.ρ, h: dk.h, encryptionKey1024: dk.encryptionKey1024, } } // An EncapsulationKey1024 is the public key used to produce ciphertexts to be // decapsulated by the corresponding [DecapsulationKey1024]. type EncapsulationKey1024 struct { ρ [32]byte...

  private interface Electronics {}

  private interface ConsumerFacing<T> {}

  private static class Mall<T> {
    class Shop<ProductT> {}

    abstract class Retailer<ProductT> extends Shop<ProductT>
        implements Comparator<ProductT>, ConsumerFacing<ProductT> {}
  }

  private static class Outlet<T> extends Mall<T> {}

  private interface UseIterable<T extends Iterable<?>> {}

        A result(Collector<T, A, R> collector, Iterable<T> inputs);
  }

  /**
   * Verifies that the specified expected result is always produced by collecting the specified
   * inputs, regardless of how the elements are divided.
   */
  @SafeVarargs
  @CanIgnoreReturnValue

 *   <li>It doesn't offer a way to wait for multiple events before taking action. For example, it
 *       doesn't offer a way to wait for multiple producers to all report that they're "ready," nor
 *       does it offer a way to batch multiple events from a single producer together.
 *   <li>It doesn't support backpressure and other features needed for resilience.
 *   <li>It doesn't provide much control of threading.

	}
	return target.isActive()
}

func (target *NSQTarget) isActive() (bool, error) {
	if target.producer == nil {
		producer, err := nsq.NewProducer(target.args.NSQDAddress.String(), target.config)
		if err != nil {
			return false, err
		}
		target.producer = producer
	}

	if err := target.producer.Ping(); err != nil {
		// To treat "connection refused" errors as errNotConnected.
		if xnet.IsConnRefusedErr(err) {

      assertEquals(0, Queues.drain(q, ImmutableList.of(), 1, 10, MILLISECONDS));

      Producer producer = new Producer(q, 1);
      // producing one, will ask for two
      Future<?> producerThread = threadPool.submit(producer);
      producer.beganProducing.await();

      // make sure we time out
      Stopwatch timer = Stopwatch.createStarted();

        DirFileEntryEnumIterator2 it = new DirFileEntryEnumIterator2(tree, parent, "*", null, 0);

        // Assert: enumeration is empty and close produced no extra close call (no fileId opened)
        assertFalse(it.hasNext(), "Empty listing should produce no elements");
        it.close();
        // No close should be sent because directory was never successfully opened