ru.d_shap.assertions.asimp.java.nio.FloatBufferAssertion Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of assertions Show documentation
Show all versions of assertions Show documentation
Assertions library provides facilities for the unit testing
///////////////////////////////////////////////////////////////////////////////////////////////////
// Assertions library provides facilities for the unit testing.
// Copyright (C) 2017 Dmitry Shapovalov.
//
// This file is part of assertions library.
//
// Assertions library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Assertions library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see {
/**
* Create new object.
*/
public FloatBufferAssertion() {
super();
}
@Override
protected final Class getActualValueClass() {
return FloatBuffer.class;
}
/**
* Check if the actual value is empty.
*/
public final void isEmpty() {
createFloatArrayAssertion(false).isEmpty();
}
/**
* Check if the actual value is empty.
*/
public final void isRewindAndEmpty() {
createFloatArrayAssertion(true).isEmpty();
}
/**
* Check if the actual value is null or empty.
*/
public final void isNullOrEmpty() {
createFloatArrayAssertion(false).isNullOrEmpty();
}
/**
* Check if the actual value is null or empty.
*/
public final void isRewindAndNullOrEmpty() {
createFloatArrayAssertion(true).isNullOrEmpty();
}
/**
* Check if the actual value is NOT empty.
*/
public final void isNotEmpty() {
createFloatArrayAssertion(false).isNotEmpty();
}
/**
* Check if the actual value is NOT empty.
*/
public final void isRewindAndNotEmpty() {
createFloatArrayAssertion(true).isNotEmpty();
}
/**
* Check if the actual value contains the expected value.
*
* @param expected the expected value.
*/
public final void contains(final float expected) {
createFloatArrayAssertion(false).contains(expected);
}
/**
* Check if the actual value contains the expected value.
*
* @param expected the expected value.
*/
public final void rewindAndContains(final float expected) {
createFloatArrayAssertion(true).contains(expected);
}
/**
* Check if the actual value does NOT contain the expected value.
*
* @param expected the expected value.
*/
public final void doesNotContain(final float expected) {
createFloatArrayAssertion(false).doesNotContain(expected);
}
/**
* Check if the actual value does NOT contain the expected value.
*
* @param expected the expected value.
*/
public final void rewindAndDoesNotContain(final float expected) {
createFloatArrayAssertion(true).doesNotContain(expected);
}
/**
* Check if the actual value contains all of the expected values.
*
* @param expected the expected values.
*/
public final void containsAll(final float... expected) {
createFloatArrayAssertion(false).containsAll(expected);
}
/**
* Check if the actual value contains all of the expected values.
*
* @param expected the expected values.
*/
public final void containsAll(final Iterable expected) {
createFloatArrayAssertion(false).containsAll(expected);
}
/**
* Check if the actual value contains all of the expected values.
*
* @param expected the expected values.
*/
public final void rewindAndContainsAll(final float... expected) {
createFloatArrayAssertion(true).containsAll(expected);
}
/**
* Check if the actual value contains all of the expected values.
*
* @param expected the expected values.
*/
public final void rewindAndContainsAll(final Iterable expected) {
createFloatArrayAssertion(true).containsAll(expected);
}
/**
* Check if the actual value contains all of the expected values in the specified order.
*
* @param expected the expected values.
*/
public final void containsAllInOrder(final float... expected) {
createFloatArrayAssertion(false).containsAllInOrder(expected);
}
/**
* Check if the actual value contains all of the expected values in the specified order.
*
* @param expected the expected values.
*/
public final void containsAllInOrder(final Iterable expected) {
createFloatArrayAssertion(false).containsAllInOrder(expected);
}
/**
* Check if the actual value contains all of the expected values in the specified order.
*
* @param expected the expected values.
*/
public final void rewindAndContainsAllInOrder(final float... expected) {
createFloatArrayAssertion(true).containsAllInOrder(expected);
}
/**
* Check if the actual value contains all of the expected values in the specified order.
*
* @param expected the expected values.
*/
public final void rewindAndContainsAllInOrder(final Iterable expected) {
createFloatArrayAssertion(true).containsAllInOrder(expected);
}
/**
* Check if the actual value contains all of the expected values exactly.
*
* @param expected the expected values.
*/
public final void containsExactly(final float... expected) {
createFloatArrayAssertion(false).containsExactly(expected);
}
/**
* Check if the actual value contains all of the expected values exactly.
*
* @param expected the expected values.
*/
public final void containsExactly(final Iterable expected) {
createFloatArrayAssertion(false).containsExactly(expected);
}
/**
* Check if the actual value contains all of the expected values exactly.
*
* @param expected the expected values.
*/
public final void rewindAndContainsExactly(final float... expected) {
createFloatArrayAssertion(true).containsExactly(expected);
}
/**
* Check if the actual value contains all of the expected values exactly.
*
* @param expected the expected values.
*/
public final void rewindAndContainsExactly(final Iterable expected) {
createFloatArrayAssertion(true).containsExactly(expected);
}
/**
* Check if the actual value contains all of the expected values exactly in the specified order.
*
* @param expected the expected values.
*/
public final void containsExactlyInOrder(final float... expected) {
createFloatArrayAssertion(false).containsExactlyInOrder(expected);
}
/**
* Check if the actual value contains all of the expected values exactly in the specified order.
*
* @param expected the expected values.
*/
public final void containsExactlyInOrder(final Iterable expected) {
createFloatArrayAssertion(false).containsExactlyInOrder(expected);
}
/**
* Check if the actual value contains all of the expected values exactly in the specified order.
*
* @param expected the expected values.
*/
public final void rewindAndContainsExactlyInOrder(final float... expected) {
createFloatArrayAssertion(true).containsExactlyInOrder(expected);
}
/**
* Check if the actual value contains all of the expected values exactly in the specified order.
*
* @param expected the expected values.
*/
public final void rewindAndContainsExactlyInOrder(final Iterable expected) {
createFloatArrayAssertion(true).containsExactlyInOrder(expected);
}
/**
* Check if the actual value contains any of the expected values.
*
* @param expected the expected values.
*/
public final void containsAny(final float... expected) {
createFloatArrayAssertion(false).containsAny(expected);
}
/**
* Check if the actual value contains any of the expected values.
*
* @param expected the expected values.
*/
public final void containsAny(final Iterable expected) {
createFloatArrayAssertion(false).containsAny(expected);
}
/**
* Check if the actual value contains any of the expected values.
*
* @param expected the expected values.
*/
public final void rewindAndContainsAny(final float... expected) {
createFloatArrayAssertion(true).containsAny(expected);
}
/**
* Check if the actual value contains any of the expected values.
*
* @param expected the expected values.
*/
public final void rewindAndContainsAny(final Iterable expected) {
createFloatArrayAssertion(true).containsAny(expected);
}
/**
* Check if the actual value does NOT contain any of the expected values.
*
* @param expected the expected values.
*/
public final void containsNone(final float... expected) {
createFloatArrayAssertion(false).containsNone(expected);
}
/**
* Check if the actual value does NOT contain any of the expected values.
*
* @param expected the expected values.
*/
public final void containsNone(final Iterable expected) {
createFloatArrayAssertion(false).containsNone(expected);
}
/**
* Check if the actual value does NOT contain any of the expected values.
*
* @param expected the expected values.
*/
public final void rewindAndContainsNone(final float... expected) {
createFloatArrayAssertion(true).containsNone(expected);
}
/**
* Check if the actual value does NOT contain any of the expected values.
*
* @param expected the expected values.
*/
public final void rewindAndContainsNone(final Iterable expected) {
createFloatArrayAssertion(true).containsNone(expected);
}
/**
* Make assertion about the actual value's position.
*
* @return the assertion.
*/
public final IntAssertion toPosition() {
checkActualIsNotNull();
return initializeAssertion(Raw.intAssertion(), getActual().position(), Messages.Check.POSITION);
}
/**
* Make assertion about the actual value's position.
*
* @param matcher the hamcrest matcher.
*/
public final void toPosition(final Matcher matcher) {
checkActualIsNotNull();
checkArgumentIsNotNull(matcher, "matcher");
matcherAssertion(getActual().position(), matcher, Messages.Check.POSITION);
}
/**
* Check if the actual value's position is equal to the expected position.
*
* @param expected the expected position.
*/
public final void hasPosition(final int expected) {
toPosition().isEqualTo(expected);
}
/**
* Make assertion about the actual value's limit.
*
* @return the assertion.
*/
public final IntAssertion toLimit() {
checkActualIsNotNull();
return initializeAssertion(Raw.intAssertion(), getActual().limit(), Messages.Check.LIMIT);
}
/**
* Make assertion about the actual value's limit.
*
* @param matcher the hamcrest matcher.
*/
public final void toLimit(final Matcher matcher) {
checkActualIsNotNull();
checkArgumentIsNotNull(matcher, "matcher");
matcherAssertion(getActual().limit(), matcher, Messages.Check.LIMIT);
}
/**
* Check if the actual value's limit is equal to the expected limit.
*
* @param expected the expected limit.
*/
public final void hasLimit(final int expected) {
toLimit().isEqualTo(expected);
}
/**
* Make assertion about the actual value's capacity.
*
* @return the assertion.
*/
public final IntAssertion toCapacity() {
checkActualIsNotNull();
return initializeAssertion(Raw.intAssertion(), getActual().capacity(), Messages.Check.CAPACITY);
}
/**
* Make assertion about the actual value's capacity.
*
* @param matcher the hamcrest matcher.
*/
public final void toCapacity(final Matcher matcher) {
checkActualIsNotNull();
checkArgumentIsNotNull(matcher, "matcher");
matcherAssertion(getActual().capacity(), matcher, Messages.Check.CAPACITY);
}
/**
* Check if the actual value's capacity is equal to the expected capacity.
*
* @param expected the expected capacity.
*/
public final void hasCapacity(final int expected) {
toCapacity().isEqualTo(expected);
}
/**
* Check if the actual value's properties are equal to the expected properties.
*
* @param expectedPosition the expected position.
* @param expectedLimit the expected limit.
* @param expectedCapacity the expected capacity.
*/
public final void hasProperties(final int expectedPosition, final int expectedLimit, final int expectedCapacity) {
hasPosition(expectedPosition);
hasLimit(expectedLimit);
hasCapacity(expectedCapacity);
}
/**
* Make assertion about the actual value's remaining.
*
* @return the assertion.
*/
public final IntAssertion toRemaining() {
checkActualIsNotNull();
return initializeAssertion(Raw.intAssertion(), getActual().remaining(), Messages.Check.REMAINING);
}
/**
* Make assertion about the actual value's remaining.
*
* @param matcher the hamcrest matcher.
*/
public final void toRemaining(final Matcher matcher) {
checkActualIsNotNull();
checkArgumentIsNotNull(matcher, "matcher");
matcherAssertion(getActual().remaining(), matcher, Messages.Check.REMAINING);
}
/**
* Check if the actual value's remaining is equal to the expected remaining.
*
* @param expected the expected remaining.
*/
public final void hasRemaining(final int expected) {
toRemaining().isEqualTo(expected);
}
/**
* Check if the actual value is direct.
*/
public final void isDirect() {
checkActualIsNotNull();
if (!getActual().isDirect()) {
throw getAssertionErrorBuilder().addMessage(Messages.Fail.Actual.IS_DIRECT).build();
}
}
/**
* Check if the actual value is NOT direct.
*/
public final void isNotDirect() {
checkActualIsNotNull();
if (getActual().isDirect()) {
throw getAssertionErrorBuilder().addMessage(Messages.Fail.Actual.IS_NOT_DIRECT).build();
}
}
/**
* Check if the actual value is read only.
*/
public final void isReadOnly() {
checkActualIsNotNull();
if (!getActual().isReadOnly()) {
throw getAssertionErrorBuilder().addMessage(Messages.Fail.Actual.IS_READ_ONLY).build();
}
}
/**
* Check if the actual value is NOT read only.
*/
public final void isNotReadOnly() {
checkActualIsNotNull();
if (getActual().isReadOnly()) {
throw getAssertionErrorBuilder().addMessage(Messages.Fail.Actual.IS_NOT_READ_ONLY).build();
}
}
private FloatArrayAssertion createFloatArrayAssertion(final boolean rewind) {
float[] floats = convertValue(getActual(), null, float[].class, rewind);
return initializeAssertion(Raw.floatArrayAssertion(), floats);
}
}