@Test public void parsesLargeTableInReasonableTime(){ thrown.expect(AssertionError.class); WebElement table = t.find(only(tableElement().that(hasName("a_large_table_with_11_cols_34_rows")))); long timeBefore = System.currentTimeMillis(); //TODO - figure out if can get rid of needing dataCellWithTextfix IsTableCell.with to accept string matchers as well as cell matchers assertThat(table,isTableElementThat(hasDataRows( includesCells(valueInColumn("Stock Code",cellWithText(startsWith("VOD.L"))), valueInColumn("Price","1.23")), includesCells(valueInColumn("Stock Description",cellWithText(startsWith("Marks"))), valueInColumn("Price","4.56")), includesCells(valueInColumn(4,"GB")), includesCells(valueInColumn("Country","US"))))); int timeTakenSecs = (int) ((System.currentTimeMillis()-timeBefore)/1000l); System.out.println("completed in " + timeTakenSecs + " seconds"); assertThat("completes in less than 10 seconds",timeTakenSecs,OrderingComparison.lessThan(10)); }
@Test public void test8_disableJsr303Validation() { // given Randomito.custom().disableJsr303().init(this); // then assertThat(test8_user, is(notNullValue())); // by default generated String is of length 150 assertThat(test8_user.getLogin().length(), OrderingComparison.greaterThan(30)); }
@Test public void testFuture() { // given Wrapper wrapper = new Wrapper(); Date future = postprocess(wrapper, "future", Date.class); Assert.assertThat(future, OrderingComparison.greaterThan(new Date())); }
@Test public void testPast() { // given Wrapper wrapper = new Wrapper(); Date past = postprocess(wrapper, "past", Date.class); Assert.assertThat(past, OrderingComparison.lessThan(new Date())); }
@Test public void testMinAnnotation() { // given Wrapper wrapper = new Wrapper(); // when Integer min = postprocess(wrapper, "min", Integer.class); // then Assert.assertThat(min, OrderingComparison.greaterThanOrEqualTo(10)); }
@Test public void testMaxAnnotation() { // given Wrapper wrapper = new Wrapper(); // when Long max = postprocess(wrapper, "max", Long.class); // then Assert.assertThat(max, OrderingComparison.lessThan(10l)); }
@Test public void testMinMaxAnnotation() { // given Wrapper wrapper = new Wrapper(); // when Float minMax = postprocess(wrapper, "minMax", Float.class); // then Assert.assertThat(minMax, OrderingComparison.greaterThanOrEqualTo(5f)); Assert.assertThat(minMax, OrderingComparison.lessThan(10f)); }
@Test public void testMinMaxOnStringAnnotation() { // given Wrapper wrapper = new Wrapper(); wrapper.string = "abcdefghijklmon......."; // when String minMax = postprocess(wrapper, "string", String.class); // then Assert.assertThat(minMax.length(), OrderingComparison.greaterThan(2)); Assert.assertThat(minMax.length(), OrderingComparison.lessThanOrEqualTo(5)); }
@Test public void testSizeOnInt() { // given Wrapper wrapper = new Wrapper(); // when Integer anInt = postprocess(wrapper, "anInt", Integer.class); // then Assert.assertThat(anInt, OrderingComparison.lessThan(20)); }
@Test public void testThresholdsDuringSteal() { UpfrontAllocatingPageSource source = new UpfrontAllocatingPageSource(new HeapBufferSource(), MemoryUnit.KILOBYTES.toBytes(1), MemoryUnit.KILOBYTES.toBytes(1)); SimpleOwner owner = new SimpleOwner(); OffHeapStorageArea storage = new OffHeapStorageArea(PointerSize.INT, owner, source, 128, false, true); owner.bind(storage); final AtomicBoolean rising512 = new AtomicBoolean(); source.addAllocationThreshold(ThresholdDirection.RISING, 512, () -> rising512.set(true)); final AtomicBoolean falling64 = new AtomicBoolean(); source.addAllocationThreshold(ThresholdDirection.FALLING, 64, () -> falling64.set(true)); long victim = storage.allocate(128); assertThat(victim, OrderingComparison.greaterThanOrEqualTo(0L)); assertThat(rising512.getAndSet(false), is(false)); assertThat(falling64.getAndSet(false), is(false)); Page thief = source.allocate(1024, true, false, null); assertThat(thief, IsNull.notNullValue()); assertThat(storage.getAllocatedMemory(), is(0L)); assertThat(rising512.getAndSet(false), is(true)); assertThat(falling64.getAndSet(false), is(true)); long fail = storage.allocate(128); assertThat(fail, is(-1L)); assertThat(storage.getAllocatedMemory(), is(0L)); assertThat(rising512.getAndSet(false), is(false)); assertThat(falling64.getAndSet(false), is(false)); source.free(thief); assertThat(storage.getAllocatedMemory(), is(0L)); assertThat(source.getAllocatedSize(), is(0L)); assertThat(rising512.getAndSet(false), is(false)); assertThat(falling64.getAndSet(false), is(true)); }
/** * Matches a <code>byte</code> parameter greater than or equal to the given value. * * @return <code>0</code> */ static public byte geq(byte value) { return argThat(Byte.TYPE, OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches a <code>char</code> parameter greater than or equal to the given value. * * @return <code>'\0'</code> */ static public char geq(char value) { return argThat(Character.TYPE, OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches a {@link Comparable} parameter greater than or equal to the given value. * * @return <code>null</code> */ @SuppressWarnings("unchecked") static public <T extends Comparable<T>> T geq(T value) { return (T) argThat(Comparable.class, (Matcher) OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches a <code>double</code> parameter greater than or equal to the given value. * * @return <code>0</code> */ static public double geq(double value) { return argThat(Double.TYPE, OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches a <code>float</code> parameter greater than or equal to the given value. * * @return <code>0</code> */ static public float geq(float value) { return argThat(Float.TYPE, OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches an <code>int</code> parameter greater than or equal to the given value. * * @return <code>0</code> */ static public int geq(int value) { return argThat(Integer.TYPE, OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches a <code>long</code> parameter greater than or equal to the given value. * * @return <code>0</code> */ static public long geq(long value) { return argThat(Long.TYPE, OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches a <code>short</code> parameter greater than or equal to the given value. * * @return <code>0</code> */ static public short geq(short value) { return argThat(Short.TYPE, OrderingComparison.greaterThanOrEqualTo(value)); }
/** * Matches a <code>byte</code> parameter greater than the given value. * * @return <code>0</code> */ static public byte gt(byte value) { return argThat(Byte.TYPE, OrderingComparison.greaterThan(value)); }
/** * Matches a <code>char</code> parameter greater than the given value. * * @return <code>'\0'</code> */ static public char gt(char value) { return argThat(Character.TYPE, OrderingComparison.greaterThan(value)); }
/** * Matches a {@link Comparable} parameter greater than the given value. * * @return <code>null</code> */ @SuppressWarnings("unchecked") static public <T extends Comparable<T>> T gt(T value) { return (T) argThat(Comparable.class, (Matcher) OrderingComparison.greaterThan(value)); }
/** * Matches a <code>double</code> parameter greater than the given value. * * @return <code>0</code> */ static public double gt(double value) { return argThat(Double.TYPE, OrderingComparison.greaterThan(value)); }
/** * Matches a <code>float</code> parameter greater than the given value. * * @return <code>0</code> */ static public float gt(float value) { return argThat(Float.TYPE, OrderingComparison.greaterThan(value)); }
/** * Matches an <code>int</code> parameter greater than the given value. * * @return <code>0</code> */ static public int gt(int value) { return argThat(Integer.TYPE, OrderingComparison.greaterThan(value)); }
/** * Matches a <code>long</code> parameter greater than the given value. * * @return <code>0</code> */ static public long gt(long value) { return argThat(Long.TYPE, OrderingComparison.greaterThan(value)); }
/** * Matches a <code>short</code> parameter greater than the given value. * * @return <code>0</code> */ static public short gt(short value) { return argThat(Short.TYPE, OrderingComparison.greaterThan(value)); }
/** * Matches a <code>byte</code> parameter less than or equal to the given value. * * @return <code>0</code> */ static public byte leq(byte value) { return argThat(Byte.TYPE, OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches a <code>char</code> parameter less than or equal to the given value. * * @return <code>'\0'</code> */ static public char leq(char value) { return argThat(Character.TYPE, OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches a {@link Comparable} parameter less than or equal to the given value. * * @return <code>null</code> */ @SuppressWarnings("unchecked") static public <T extends Comparable<T>> T leq(T value) { return (T) argThat(Comparable.class, (Matcher) OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches a <code>double</code> parameter less than or equal to the given value. * * @return <code>0</code> */ static public double leq(double value) { return argThat(Double.TYPE, OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches a <code>float</code> parameter less than or equal to the given value. * * @return <code>0</code> */ static public float leq(float value) { return argThat(Float.TYPE, OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches an <code>int</code> parameter less than or equal to the given value. * * @return <code>0</code> */ static public int leq(int value) { return argThat(Integer.TYPE, OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches a <code>long</code> parameter less than or equal to the given value. * * @return <code>0</code> */ static public long leq(long value) { return argThat(Long.TYPE, OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches a <code>short</code> parameter less than or equal to the given value. * * @return <code>0</code> */ static public short leq(short value) { return argThat(Short.TYPE, OrderingComparison.lessThanOrEqualTo(value)); }
/** * Matches a <code>byte</code> parameter less than the given value. * * @return <code>0</code> */ static public byte lt(byte value) { return argThat(Byte.TYPE, OrderingComparison.lessThan(value)); }
/** * Matches a <code>char</code> parameter less than the given value. * * @return <code>'\0'</code> */ static public char lt(char value) { return argThat(Character.TYPE, OrderingComparison.lessThan(value)); }
/** * Matches a {@link Comparable} parameter less than the given value. * * @return <code>null</code> */ @SuppressWarnings("unchecked") static public <T extends Comparable<T>> T lt(T value) { return (T) argThat(Comparable.class, (Matcher) OrderingComparison.lessThan(value)); }
/** * Matches a <code>double</code> parameter less than the given value. * * @return <code>0</code> */ static public double lt(double value) { return argThat(Double.TYPE, OrderingComparison.lessThan(value)); }
/** * Matches a <code>float</code> parameter less than the given value. * * @return <code>0</code> */ static public float lt(float value) { return argThat(Float.TYPE, OrderingComparison.lessThan(value)); }
/** * Matches an <code>int</code> parameter less than the given value. * * @return <code>0</code> */ static public int lt(int value) { return argThat(Integer.TYPE, OrderingComparison.lessThan(value)); }