org.junit.contrib.theories.Theory的实例源码

项目：loglinear    文件：TableFactorTest.java   

@Theory
public void testMultiply(@ForAll(sampleSize = 10) @From(TableFactorGenerator.class) TableFactor factor1,@ForAll(sampleSize = 10) @From(TableFactorGenerator.class) TableFactor factor2) throws Exception {
  TableFactor result = factor1.multiply(factor2);

  for (int[] assignment : result) {
    double factor1Value = factor1.getAssignmentValue(subsetAssignment(assignment,result,factor1));
    double factor2Value = factor2.getAssignmentValue(subsetAssignment(assignment,factor2));
    assertEquals(factor1Value * factor2Value,result.getAssignmentValue(assignment),1.0e-5);
  }

  // Check for no duplication
  for (int i = 0; i < result.neighborIndices.length; i++) {
    for (int j = 0; j < result.neighborIndices.length; j++) {
      if (i == j) continue;
      assertNotSame(result.neighborIndices[i],result.neighborIndices[j]);
    }
  }
}

项目：loglinear    文件：ConcatVectorNamespaceTest.java   

@Theory
public void testResizeOnSetComponent(@ForAll(sampleSize = 50) @From(MapGenerator.class) Map<Integer,Integer> featureMap1,@ForAll(sampleSize = 50) @From(MapGenerator.class) Map<Integer,Integer> featureMap2) {
    ConcatVectorNamespace namespace = new ConcatVectorNamespace();

    ConcatVector namespace1 = toNamespaceVector(namespace,featureMap1);
    ConcatVector namespace2 = toNamespaceVector(namespace,featureMap2);

    ConcatVector regular1 = toVector(featureMap1);
    ConcatVector regular2 = toVector(featureMap2);

    assertEquals(regular1.dotProduct(regular2),namespace1.dotProduct(namespace2),1.0e-5);

    ConcatVector namespaceSum = namespace1.deepClone();
    namespaceSum.addVectorInPlace(namespace2,1.0);

    ConcatVector regularsum = regular1.deepClone();
    regularsum.addVectorInPlace(regular2,1.0);

    assertEquals(regular1.dotProduct(regularsum),namespace1.dotProduct(namespaceSum),1.0e-5);
    assertEquals(regularsum.dotProduct(regular2),namespaceSum.dotProduct(namespace2),1.0e-5);
}

项目：loglinear    文件：ConcatVectorNamespaceTest.java   

@Theory
public void testProtoNamespace(@ForAll(sampleSize = 50) @From(NamespaceGenerator.class) ConcatVectorNamespace namespace) throws IOException {
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

    namespace.writetoStream(byteArrayOutputStream);
    byteArrayOutputStream.close();

    byte[] bytes = byteArrayOutputStream.toByteArray();

    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);

    ConcatVectorNamespace recovered = ConcatVectorNamespace.readFromStream(byteArrayInputStream);

    assertEquals(namespace.featuretoIndex,recovered.featuretoIndex);
    assertEquals(namespace.sparseFeatureIndex,recovered.sparseFeatureIndex);
    assertEquals(namespace.reverseSparseFeatureIndex,recovered.reverseSparseFeatureIndex);
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testGetSparseIndex(@ForAll(sampleSize = 10) @InRange(minInt = 0,maxInt = 10000) int sparse1,@ForAll(sampleSize = 10) double sparse1Val,@ForAll(sampleSize = 10) @InRange(minInt = 0,maxInt = 10000) int sparse2,@ForAll(sampleSize = 10) double sparse2Val) throws Exception {
    ConcatVector v1 = new ConcatVector(2);
    ConcatVector v2 = new ConcatVector(2);

    v1.setSparseComponent(0,sparse1,sparse1Val);
    v1.setSparseComponent(1,sparse2,sparse1Val);
    v2.setSparseComponent(0,sparse2Val);
    v2.setSparseComponent(1,sparse2Val);

    assertEquals(sparse1,v1.getSparseIndex(0));
    assertEquals(sparse2,v1.getSparseIndex(1));
    assertEquals(sparse2,v2.getSparseIndex(0));
    assertEquals(sparse1,v2.getSparseIndex(1));
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testElementwiseSparsetoSparse(@ForAll(sampleSize = 20) @InRange(minInt = 0,maxInt = 10) int sparseIndex1,@ForAll(sampleSize = 10) double val1,@ForAll(sampleSize = 20) @InRange(minInt = 0,maxInt = 10) int sparseIndex2,@ForAll(sampleSize = 10) double val2) {
    ConcatVector v1 = new ConcatVector(1);
    v1.setSparseComponent(0,sparseIndex1,val1);
    ConcatVector v2 = new ConcatVector(1);
    v2.setSparseComponent(0,sparseIndex2,val2);

    v1.elementwiseProductInPlace(v2);
    for (int i = 0; i < 10; i++) {
        double expected = 0.0f;
        if (i == sparseIndex1 && i == sparseIndex2) expected = val1 * val2;
        assertEquals(expected,v1.getValueAt(0,i),5.0e-4);
    }
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testAppendSparseComponent(@ForAll(sampleSize = 10) @InRange(minInt = 0,@ForAll(sampleSize = 10) double sparse2Val) throws Exception {
    ConcatVector v1 = new ConcatVector(1);
    ConcatVector v2 = new ConcatVector(1);

    v1.setSparseComponent(0,sparse2Val);

    if (sparse1 == sparse2) {
        assertEquals(sparse1Val*sparse2Val,v1.dotProduct(v2),5.0e-4);
    }
    else {
        assertEquals(0.0,5.0e-4);
    }
}

项目：loglinear    文件：TableFactorTest.java   

@Theory
public void testConstructWithObservations(@ForAll(sampleSize = 50) @From(PartiallyObservedConstructorDataGenerator.class) PartiallyObservedConstructorData data,@ForAll(sampleSize = 2) @From(ConcatVectorGenerator.class) ConcatVector weights) throws Exception {
  int[] obsArray = new int[9];
  for (int i = 0; i < obsArray.length; i++) obsArray[i] = -1;
  for (int i = 0; i < data.observations.length; i++) {
    obsArray[data.factor.neigborIndices[i]] = data.observations[i];
  }

  TableFactor normalObservations = new TableFactor(weights,data.factor);
  for (int i = 0; i < obsArray.length; i++) {
    if (obsArray[i] != -1) {
      normalObservations = normalObservations.observe(i,obsArray[i]);
    }
  }

  TableFactor constructedobservations = new TableFactor(weights,data.factor,data.observations);

  assertArrayEquals(normalObservations.neighborIndices,constructedobservations.neighborIndices);
  for (int[] assn : normalObservations) {
    assertEquals(normalObservations.getAssignmentValue(assn),constructedobservations.getAssignmentValue(assn),1.0e-9);
  }
}

项目：loglinear    文件：TableFactorTest.java   

@Theory
public void testObserve(@ForAll(sampleSize = 50) @From(TableFactorGenerator.class) TableFactor factor,@ForAll(sampleSize = 2) @InRange(minInt = 0,maxInt = 3) int observe,maxInt = 1) int value) throws Exception {
  if (!Arrays.stream(factor.neighborIndices).Boxed().collect(Collectors.toSet()).contains(observe)) return;
  if (factor.neighborIndices.length == 1) return;

  TableFactor observedOut = factor.observe(observe,value);

  int observeIndex = -1;
  for (int i = 0; i < factor.neighborIndices.length; i++) {
    if (factor.neighborIndices[i] == observe) observeIndex = i;
  }

  for (int[] assignment : factor) {
    if (assignment[observeIndex] == value) {
      assertEquals(factor.getAssignmentValue(assignment),observedOut.getAssignmentValue(subsetAssignment(assignment,factor,observedOut)),1.0e-7);
    }
  }
}

项目：lense    文件：GameTest.java   

@Theory
public void testLegalMoves(@ForAll(sampleSize = 10) @From(GameGenerator.class) Game game) throws Exception {
    Game.Event[] moves = game.getLegalMoves();

    boolean containsHire = false;
    boolean containsWait = false;
    boolean containsObserve = false;
    boolean containsTurnIn = false;

    for (Game.Event e : moves) {
        if (e instanceof Game.HumanJobPosting) containsHire = true;
        if (e instanceof Game.Wait) containsWait = true;
        if (e instanceof Game.QueryLaunch) containsObserve = true;
        if (e instanceof Game.TurnIn) containsTurnIn = true;
    }

    assertTrue(containsHire);
    assertFalse(containsWait);
    assertFalse(containsObserve);
    assertTrue(containsTurnIn);
}

项目：lense    文件：HumanWorkerWebSocketTest.java   

/**
 * This is basically just to check that the JSON serialization works properly,and everything is indeed hooked up to
 * the HumanSourceServer. Workers accept jobs,then do them.
 *
 * @param numThreads
 * @param numJobs
 * @throws Exception
 */
@Theory
public void testQueries(@ForAll(sampleSize = 2) @InRange(maxInt = 10,minInt = 2) int numThreads,@ForAll(sampleSize = 2) @InRange(maxInt = 100,minInt = 20) int numJobs) throws Exception {
    List<WebSocketMockbrowser> mockbrowsers = new ArrayList<>();

    HumanSourceServerTest.busyTest(() -> {
        WebSocketMockbrowser mockWorkerWithbrowser = new WebSocketMockbrowser();
        mockbrowsers.add(mockWorkerWithbrowser);
        new Thread(mockWorkerWithbrowser).start();
        return mockWorkerWithbrowser;
    },numThreads,numJobs);

    // Test that the payment system is working

    for (WebSocketMockbrowser mockbrowser : mockbrowsers) {
        Assert.assertEquals(HistoricalDatabase.numberOfTasksThisWorkUnit("" + mockbrowser.workerID),mockbrowser.totalQueriesReceived);
    }
}

项目：loglinear    文件：CliqueTreeTest.java   

@Theory
public void testCompilenormalizedModel(@ForAll(sampleSize = 1000) @From(GraphicalModelGenerator.class) GraphicalModel model,@ForAll(sampleSize = 10) @From(WeightsGenerator.class) ConcatVector weights) throws Exception {
  CliqueTree.MarginalResult unnormalizedSolve = new CliqueTree(model,weights).calculateMarginals();
  GraphicalModel normalized = new CliqueTree(model,weights).compilenormalizedModel();
  CliqueTree.MarginalResult normalizedSolve = new CliqueTree(normalized,weights).calculateMarginals();
  assertEquals(unnormalizedSolve,normalizedSolve);


  double partitionWithWeights = normalizedSolve.partitionFunction;
  double partitionWithoutWeights = new CliqueTree(normalized,new ConcatVector(0)).calculateMarginals().partitionFunction;
  assertEquals(partitionWithoutWeights,partitionWithWeights,1e-5);
  assertFalse(Double.isNaN(partitionWithoutWeights));
  assertFalse(Double.isNaN(partitionWithWeights));
  assertEquals(1.0,1e-5);
  assertEquals(1.0,partitionWithoutWeights,1e-5);
}

项目：loglinear    文件：ModelBatchTest.java   

@Theory
public void testProtoBatch(@ForAll(sampleSize = 50) @From(BatchGenerator.class) ModelBatch batch) throws IOException {
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

    batch.writetoStream(byteArrayOutputStream);
    byteArrayOutputStream.close();

    byte[] bytes = byteArrayOutputStream.toByteArray();

    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);

    ModelBatch recovered = new ModelBatch(byteArrayInputStream);
    byteArrayInputStream.close();

    assertEquals(batch.size(),recovered.size());

    for (int i = 0; i < batch.size(); i++) {
        assertTrue(batch.get(i).valueEquals(recovered.get(i),1.0e-5));
    }
}

项目：loglinear    文件：ModelLogdiskTest.java   

@Theory
public void testProtoBatch(@ForAll(sampleSize = 50) @From(ModelBatchTest.BatchGenerator.class) ModelBatch batch) throws IOException {
    ByteArrayInputStream emptyInputStream = new ByteArrayInputStream(new byte[0]);
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

    ModelLog log = new ModelLogdisk(emptyInputStream,byteArrayOutputStream);
    log.writeWithFactors = true;
    for (GraphicalModel model : batch) {
        log.add(model);
    }
    log.close();

    byte[] bytes = byteArrayOutputStream.toByteArray();
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);

    ModelLog recovered = new ModelLogdisk(byteArrayInputStream,byteArrayOutputStream);
    byteArrayInputStream.close();

    assertEquals(batch.size(),1.0e-5));
    }
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testElementwiseDensetoSparse(@ForAll(sampleSize = 50) double[] dense1,maxInt = 100) int sparseIndex,@ForAll(sampleSize = 10) double v) {
    assumeTrue(sparseIndex >= 0);
    assumeTrue(sparseIndex <= 100);
    ConcatVector v1 = new ConcatVector(1);
    v1.setDenseComponent(0,dense1);
    ConcatVector v2 = new ConcatVector(1);
    v2.setSparseComponent(0,sparseIndex,v);

    v2.elementwiseProductInPlace(v1);
    for (int i = 0; i < dense1.length; i++) {
        double expected = 0.0f;
        if (i == sparseIndex) expected = dense1[i] * v;
        assertEquals(expected,v2.getValueAt(0,5.0e-4);
    }
}

项目：RedRadishes    文件：BulkStringParserTest.java   

@Theory
public <B> void returnsFailureIfBulkStringBuilderThrowsException(@ForAll byte[] bytes,@TestedOn(ints = {1,2,3,5,100}) int bufferSize) throws Exception {
  @SuppressWarnings("unchecked") BulkStringBuilderFactory<B,?> bulkStringBuilderFactory =
      mock(BulkStringBuilderFactory.class);
  RuntimeException e1 = new RuntimeException();
  RuntimeException e2 = new RuntimeException();
  when(bulkStringBuilderFactory.append(any(),any(),any())).thenThrow(e1,e2);
  boolean oneChunk = bytes.length <= bufferSize;
  when(bulkStringBuilderFactory.appendLast(any(),any())).thenThrow(oneChunk ? e1 : e2);

  ByteBuffer src = ByteBuffer.wrap(appendCRLF(bytes));
  assertthat(
      parseReply(src,bufferSize,new BulkStringParser<>(bytes.length,bulkStringBuilderFactory),assertnoresult(),e -> e,charsetDecoder),equalTo(e1));
  verifyZeroInteractions(charsetDecoder);
  verify(bulkStringBuilderFactory).create(bytes.length,charsetDecoder);
  if (oneChunk) {
    verify(bulkStringBuilderFactory).appendLast(any(),eq(charsetDecoder));
  } else {
    verify(bulkStringBuilderFactory).append(any(),eq(charsetDecoder));
  }
  verifyNoMoreInteractions(bulkStringBuilderFactory);
}

项目：loglinear    文件：TableFactorTest.java   

@Theory
public void testGetBestAssignment(@ForAll(sampleSize = 1000) @From(TableFactorGenerator.class) TableFactor factor) {
  int[] bestAssignment = factor.getBestAssignment();
  for (int[] assn : factor) {
    assertTrue(factor.getAssignmentValue(assn) <= factor.getAssignmentValue(bestAssignment));
  }
}

项目：RedRadishes    文件：RepliesTest.java   

@Theory
public void parsesScanReply(@ForAll(sampleSize = 10) @InRange(minLong = 0) long cursor,@ForAll(sampleSize = 50) byte[][] elements,@TestedOn(ints = {3,10,100,1000}) int bufferSize) {
  ByteBuffer src = ByteBuffer.wrap(encodeScanReply(cursor,elements));
  ScanResult<byte[][]> scanResult =
      parseReply(src,scanReply(array(byte[][]::new),new TestBulkStringBuilderFactory()),Function.identity(),assertNoFailure(),charsetDecoder);
  assertthat(scanResult.cursor,equalTo(cursor));
  assertthat(scanResult.elements,equalTo(elements));
  verifyZeroInteractions(charsetDecoder);
}

项目：junit-theory-suite    文件：ArgumentSetTest.java   

@Theory
public void canCallHasNextFreely(ArgumentSet as) {

    Iterator<?> iter = as.iterator();

    while (iter.hasNext()) {
        assertTrue(iter.hasNext());
        iter.next();
    }
    assertTrue(!iter.hasNext());

}

项目：loglinear    文件：GraphicalModelTest.java   

@Theory
public void testGetvariableSizes(@ForAll(sampleSize = 50) @From(GraphicalModelGenerator.class) GraphicalModel graphicalModel) throws IOException {
  int[] sizes = graphicalModel.getvariableSizes();

  for (GraphicalModel.Factor f : graphicalModel.factors) {
    for (int i = 0; i < f.neigborIndices.length; i++) {
      assertEquals(f.getDimensions()[i],sizes[f.neigborIndices[i]]);
    }
  }
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testAddSparsetoSparse(@ForAll(sampleSize = 20) @InRange(minInt = 0,val2);

    double expected = v1.dotProduct(v2) + 0.7f*(v2.dotProduct(v2));
    v1.addVectorInPlace(v2,0.7f);
    assertEquals(expected,5.0e-3);
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testRetrieveDense(@ForAll(sampleSize = 50) @From(DenseTestVectorGenerator.class) DenseTestVector d1) {
    int size = d1.vector.getNumberOfComponents();
    assertEquals(d1.values.length,size);
    for (int i = 0; i < d1.values.length; i++) {
        if (!d1.vector.isComponentSparse(i)) {
            assertArrayEquals(d1.values[i],d1.vector.getDenseComponent(i),1.0e-9);
        }
    }
}

项目：RedRadishes    文件：RepliesTest.java   

@Theory
public void parsesBulkStringReply(@ForAll byte[] bytes,100}) int bufferSize) {
  ByteBuffer src = ByteBuffer.wrap(encodeBulkString(bytes));
  assertthat(parseReply(src,bulkStringReply(new TestBulkStringBuilderFactory()),equalTo(bytes));
  verifyZeroInteractions(charsetDecoder);
}

项目：junit-theory-suite    文件：EqualsHashCodeTest.java   

@Theory
@Pairwise
@WithConstraints("equals")
public void equalsIsTransitive(Object x,Object y,Object z) {

    assertTrue(z.equals(x));
}

项目：RedRadishes    文件：RepliesTest.java   

@Theory
public <E> void failsToParseArrayReplyIfIntegerReplyIsFound(@ForAll long num,100}) int bufferSize) {
  ByteBuffer src = ByteBuffer.wrap(encodeInteger(num));
  @SuppressWarnings("unchecked") ArrayBuilderFactory<E,?> arrayBuilderFactory = mock(ArrayBuilderFactory.class);
  @SuppressWarnings("unchecked") BulkStringBuilderFactory<?,E> bulkStringBuilderFactory =
      mock(BulkStringBuilderFactory.class);
  failsToParseReply(src,arrayReply(arrayBuilderFactory,"Command returned integer reply while array reply was expected");
  verifyZeroInteractions(bulkStringBuilderFactory);
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testElementwiseSparsetoDense(@ForAll(sampleSize = 50) double[] dense1,@ForAll(sampleSize = 10) double v) {
    ConcatVector v1 = new ConcatVector(1);
    v1.setDenseComponent(0,v);

    v1.elementwiseProductInPlace(v2);
    for (int i = 0; i < dense1.length; i++) {
        double expected = 0.0f;
        if (i == sparseIndex) expected = dense1[i] * v;
        assertEquals(expected,5.0e-4);
    }
}

项目：junit-theory-suite    文件：EqualsHashCodeTest.java   

@Theory
public void equalsIsRepeatable(Object x,Object y) {
    boolean alwaysTheSame = x.equals(y);

    for (int i = 0; i < 30; i++)
        assertthat(x.equals(y),is(alwaysTheSame));
}

项目：RedRadishes    文件：RepliesTest.java   

@Theory
public void parsesNullStringReply(@TestedOn(ints = {1,100}) int bufferSize) {
  ByteBuffer src = ByteBuffer.wrap(encodeNilBulkString());
  assertthat(parseReply(src,simpleStringReply(),nullValue());
  verifyZeroInteractions(charsetDecoder);
}

项目：junit-theory-suite    文件：ConstraintsExampleTest.java   

/**
 * Global constraint on arguments of a test.
 */
@Theory
public void yearDayroundtrip(Year year,Month month,int monthDay) {

    // no assume needed because of global constraint
    int dayOfYear = year.atMonth(month).atDay(monthDay).getDayOfYear();

    assertTrue(dayOfYear > 0);
    assertTrue(dayOfYear <= 366);

    assertEquals(month,year.atDay(dayOfYear).getMonth());
    assertEquals(monthDay,year.atDay(dayOfYear).getDayOfMonth());

}

项目：loglinear    文件：ConcatVectorTableTest.java   

@Theory
public void testCloneTable(@ForAll(sampleSize = 50) @From(FeatureFactorGenerator.class) ConcatVector[][][] factor3) throws IOException {
    ConcatVectorTable concatVectorTable = convertArrayToVectorTable(factor3);

    ConcatVectorTable cloned = concatVectorTable.cloneTable();
    for (int i = 0; i < factor3.length; i++) {
        for (int j = 0; j < factor3[0].length; j++) {
            for (int k = 0; k < factor3[0][0].length; k++) {
                assertTrue(factor3[i][j][k].valueEquals(cloned.getAssignmentValue(new int[]{i,j,k}).get(),1.0e-5));
            }
        }
    }
    assertTrue(concatVectorTable.valueEquals(cloned,1.0e-5));
}

项目：loglinear    文件：CliqueTreeTest.java   

@Theory
public void testCalculateMap(@ForAll(sampleSize = 100) @From(GraphicalModelGenerator.class) GraphicalModel model,@ForAll(sampleSize = 10) @From(WeightsGenerator.class) ConcatVector weights) throws Exception {
  if (model.factors.size() == 0) return;
  CliqueTree inference = new CliqueTree(model,weights);
  // This is the basic check that inference works when you first construct the model
  checkMAPAgainstBruteForce(model,weights,inference);
  // Now we go through several random mutations to the model,and check that everything is still consistent
  Random r = new Random();
  for (int i = 0; i < 10; i++) {
    randomlyMutateGraphicalModel(model,r);
    checkMAPAgainstBruteForce(model,inference);
  }
}

项目：junit-theory-suite    文件：ConstraintTest.java   

@Theory
public void inorder(boolean b1,double a,double b,double c,int i) {
    assertTrue(a <= b);
    assertTrue(b <= c);

    assertTrue(b1);
}

项目：loglinear    文件：ConcatVectorTest.java   

@Theory
public void testInnerProduct2(@ForAll(sampleSize = 10) @From(DenseTestVectorGenerator.class) DenseTestVector d1,@ForAll(sampleSize = 10) @From(DenseTestVectorGenerator.class) DenseTestVector d2,@ForAll(sampleSize = 10) @From(DenseTestVectorGenerator.class) DenseTestVector d3) throws Exception {
    // Test the invariant x^Tz + 0.7*y^Tz == (x+0.7*y)^Tz
    double d1d3 = d1.vector.dotProduct(d3.vector);
    assertEquals(d1.trueInnerProduct(d3),d1d3,5.0e-4);
    double d2d3 = d2.vector.dotProduct(d3.vector);
    assertEquals(d2.trueInnerProduct(d3),d2d3,5.0e-4);
    double expected = d1d3 + (0.7f*d2d3);
    assertEquals(d1.trueInnerProduct(d3) + (0.7*d2.trueInnerProduct(d3)),expected,5.0e-4);
}

项目：RedRadishes    文件：BulkStringBuildersTest.java   

@Theory
public void parsesCharSequences(@ForAll String value,@TestedOn(ints = {4,6,7,1000}) int bufferSize,Charset charset) {
  ByteBuffer src = ByteBuffer.wrap(encodeBulkString(value.getBytes(charset)));
  CharSequence actual =
      parseReply(src,bulkStringReply(charSequence()),charset.newDecoder());
  assertthat(actual,hasSameContentAs(value));
}

项目：RedRadishes    文件：BulkStringBuildersTest.java   

@Theory
public void parsesLongs(@ForAll long value,1000}) int bufferSize) {
  ByteBuffer src = ByteBuffer.wrap(encodeBulkString(Long.toString(value).getBytes(US_ASCII)));
  assertthat(
      parseReply(src,bulkStringReply(_long()),equalTo(value));
  verifyZeroInteractions(charsetDecoder);
}

项目：lense    文件：GamePlayerExhaustiveSearchTest.java   

@Theory
public void testQueries(@ForAll(sampleSize = 3) @From(GameTest.GameGenerator.class) Game game) throws Exception {
    Random r = new Random(23);
    game.humansAvailableServerSide = 2;

    GamePlayerExhaustiveSearch bruteForce = new GamePlayerExhaustiveSearch();

    System.err.println("Model: "+game.model.toString());

    // This means that the game tree is too large,so we quit
    Game.Event firstMove = bruteForce.getNextMove(game,new UncertaintyUtility());
    if (firstMove == null || firstMove instanceof Game.TurnIn) {
        System.err.println("Skip... "+firstMove);
        return;
    }

    GamePlayerRandom random = new GamePlayerRandom(r);

    double bruteForceUtil = 0;
    double randomUtil = 0;

    for (int i = 0; i < 10; i++) {
        game.resetEvents();
        bruteForceUtil += GamePlayerTestbed.playSimulation(r,game,bruteForce,new UncertaintyUtility()).endUtility;
        game.resetEvents();
        randomUtil += GamePlayerTestbed.playSimulation(r,random,new UncertaintyUtility()).endUtility;

        System.err.println("Brute force: " + bruteForceUtil);
        System.err.println("random: "+randomUtil);
    }

    // Over 10 runs,brute force will almost always do better than random,to the point where failure probability
    // is near 0
    assertTrue(bruteForceUtil >= randomUtil);
}

项目：lense    文件：GameTest.java   

@Theory
public void testGetClones(@ForAll(sampleSize = 10) @From(GameGenerator.class) Game game) throws Exception {
    Random r = new Random(42);
    GamePlayer gp = new GamePlayerRandom(r);

    while (!game.isTerminated()) {
        Game[] copies = game.getClones(5);
        for (int i = 0; i < copies.length; i++) {
            assertTrue(copies[i] != game);
            assertTrue(copies[i].stack.size() == game.stack.size());
            for (int j = 0; j < copies[i].stack.size(); j++) {
                assertTrue(copies[i].stack.get(j) != game.stack.get(j));
                if (!copies[i].stack.get(j).equals(game.stack.get(j))) {
                    Game.Event e1 = copies[i].stack.get(j);
                    Game.Event e2 = game.stack.get(j);
                    boolean eq = e1.equals(e2);
                    System.err.println("blah");
                }
                assertTrue(copies[i].stack.get(j).equals(game.stack.get(j)));
            }
            assertTrue(copies[i].model != game.model);
            assertTrue(copies[i].model.valueEquals(game.model,1.0e-7));
        }

        Game.Event nextMove;
        if (game.isGameplayerTurn()) {
            nextMove = gp.getNextMove(game,null);
        }
        else {
            nextMove = game.sampleNextEvent(r);
        }
        nextMove.push(game);
    }
}

项目：lense    文件：GameTest.java   

@Theory
public void testMultiquery(@ForAll(sampleSize = 10) @From(GameGenerator.class) Game game,@ForAll(sampleSize = 5) @InRange(minInt = 1,maxInt = 10) int numQueries) throws Exception {
    int initialNumVariable = numVariables(game.model);

    List<Integer> vars = new ArrayList<>();
    vars.addAll(game.availableAnnotators.keySet());

    Random r = new Random();

    for (int i = 0; i < numQueries; i++) {
        //Recruit another human
        Game.HumanJobPosting jp = new Game.HumanJobPosting();
        jp.push(game);
        Game.HumanArrival human = game.humanProvider.getArtificialHuman(game,jp);
        human.push(game);

        // Do the query
        int variable = vars.get(r.nextInt(vars.size()));
        Game.QueryLaunch ql = new Game.QueryLaunch(variable,human);
        ql.push(game);
        Game.QueryResponse qr = new Game.QueryResponse(ql,0);
        qr.push(game);

        assertEquals(initialNumVariable + i + 1,numVariables(game.model));
    }

    for (int i = 0; i < numQueries; i++) {
        // Pop the answer
        game.stack.peek().pop(game);
        // request
        game.stack.peek().pop(game);
        // humanArrival
        game.stack.peek().pop(game);
        // job posting
        game.stack.peek().pop(game);

        assertEquals(initialNumVariable + numQueries - i - 1,numVariables(game.model));
    }
}

项目：lense    文件：GameTest.java   

@Theory
public void testIsFinished(@ForAll(sampleSize = 10) @From(GameGenerator.class) Game game) throws Exception {
    Game.TurnIn t = new Game.TurnIn();
    t.push(game);
    assertTrue(game.isTerminated());
    t.pop(game);
    assertFalse(game.isTerminated());
}

项目：lense    文件：GameTest.java   

@Theory
public void testIsGameplayerTurn(@ForAll(sampleSize = 10) @From(GameGenerator.class) Game game) throws Exception {
    Game.Wait w = new Game.Wait();
    assertTrue(game.isGameplayerTurn());
    w.push(game);
    assertFalse(game.isGameplayerTurn());
    w.pop(game);
    assertTrue(game.isGameplayerTurn());
}

项目：RedRadishes    文件：RepliesTest.java   

@Theory
public void parsesArrayReply(@ForAll(sampleSize = 40) byte[][] arrays,1000}) int bufferSize) {
  ByteBuffer src = ByteBuffer.wrap(encodeArray(arrays));
  assertthat(parseReply(src,arrayReply(array(byte[][]::new),equalTo(arrays));
  verifyZeroInteractions(charsetDecoder);
}