Benchmarks can use the new [B.Loop] method in `for b.Loop() { ... }` loops to determine if iteration should continue....

        return partialResults;
    }

    public FacetResponse getFacetResponse() {
        return facetResponse;
    }

    public static SearchResultBuilder create() {
        return new SearchResultBuilder();
    }

    @Override
    public String toString() {
        return "SearchResult [documentList=" + documentList + ", allRecordCount=" + allRecordCount + ", allRecordCountRelation="

 */
public abstract class AbstractChainedListenableFutureTest<T> extends TestCase {
  protected static final int EXCEPTION_DATA = -1;
  protected static final int VALID_INPUT_DATA = 1;
  protected static final Exception EXCEPTION = new Exception("Test exception");

  protected SettableFuture<Integer> inputFuture;
  protected ListenableFuture<T> resultFuture;
  protected MockFutureListener listener;

  @Override

 *
 * @author Louis Wasserman
 */
public class BigIntegerMathRoundingBenchmark {
  private static final BigInteger[] nonzero1 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] nonzero2 = new BigInteger[ARRAY_SIZE];
  private static final BigInteger[] positive = new BigInteger[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

  @BeforeExperiment

	set[targetID] = struct{}{}
}

// Union - returns union with given set as new set.
func (set TargetIDSet) Union(sset TargetIDSet) TargetIDSet {
	nset := set.Clone()

	for k := range sset {
		nset.add(k)
	}

	return nset
}

// Difference - returns difference with given set as new set.
func (set TargetIDSet) Difference(sset TargetIDSet) TargetIDSet {
	nset := NewTargetIDSet()

local g = import 'g.libsonnet';

local variables = import './variables.libsonnet';

{
  new(name):
    g.dashboard.new(name)
    + g.dashboard.graphTooltip.withSharedCrosshair()
    + g.dashboard.withRefresh('15s')
    + g.dashboard.time.withFrom('now-30m')
    + g.dashboard.time.withTo('now')
    + g.dashboard.withVariables([variables.datasource]),

        addTraverserFactory("jar", JarFileTraverser::new);
        addTraverserFactory("zip", (url, rootPackage,
                rootDir) -> new JarFileTraverser(JarFileUtil.create(new File(ZipFileUtil.toZipFilePath(url))), rootPackage, rootDir));
        addTraverserFactory("code-source",
                (url, rootPackage, rootDir) -> new JarFileTraverser(URLUtil.create("jar:file:" + url.getPath()), rootPackage, rootDir));

}

func TestPreparedStmtInTransaction(t *testing.T) {
	user := User{Name: "jinzhu"}

	if err := DB.Transaction(func(tx *gorm.DB) error {
		tx.Session(&gorm.Session{PrepareStmt: true}).Create(&user)
		return errors.New("test")
	}); err == nil {
		t.Error(err)
	}

	var result User
	if err := DB.First(&result, user.ID).Error; err == nil {
		t.Errorf("Failed, got error: %v", err)
	}
}

            }
            cachedPathMappingList = new ArrayList<>();
        } catch (final Exception e) {
            logger.warn("Failed to load path mappings.", e);
        }
        return 0;
    }

    protected List<String> getProcessTypeList() {
        final List<String> ptList = new ArrayList<>();
        final String executeType = System.getProperty("lasta.env");

        (TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();

    List<Feature<?>> features = new ArrayList<>();
    features.add(NoRecurse.DESCENDING);
    features.addAll(parentBuilder.getFeatures());

    return subSuiteUsing(new DescendingTestMapGenerator<K, V>(delegate))
        .named(parentBuilder.getName() + " descending")
        .withFeatures(features)