Simple assertion.
975478
protected static void assertion(boolean b, String msg)
  {
  	if(!b)
  	{
  		throw new RuntimeException(XSLMessages.createMessage(XSLTErrorResources.ER_ASSERT_REDUNDENT_EXPR_ELIMINATOR, new Object[]{msg}));
  		// "Programmer's assertion in RundundentExprEliminator: "+msg);
  	}
  }
680465
def A(self):
        
        """
        if self._A is None:
            self._A = self.W > 0
        return self._A
116154
public static Boolean assertFalse(Boolean value, String message) {
        if (Boolean.valueOf(value))
            throw new IllegalArgumentException(message);
        return value;
    }
1185849
function() {
          each(this.assertions, function(assertion){
            if (assertion.defer) assertion.run().report(), hook('afterAssertion', assertion)
          })
        }
563472
function assert(t) {
	if (!t.result) {
		errorMessages.push(t.message);

		var errorDetail;
		if (t.expected === undefined && t.actual === undefined) {
			errorDetail = 'Test "' + testName + '" assertion failed' + (t.message ? ': "' + t.message + '"' : '');
		} else {
			errorDetail = 'Test "' + testName + '" assertion failed. Expected <' + t.expected + '> Actual <' + t.actual + '>' + (t.message ? ': "' + t.message + '"' : '');
		}

		errorDetails.push(errorDetail);
	}
}
984640
def assert_is(expected, actual, message=None, extra=None):
    """"""
    assert expected is actual, _assert_fail_message(
        message, expected, actual, "is not", extra
    )
279361
public CTX soThat(@Nonnull AssertionsCheck assertions) {
        normalCheck(description, caseDescription, preconditioner, assertFunction, assertPreConsumer, a -> assertions.assertionsCheck());
        return context.self();
    }
129184
public static void assertByteEquals(final Path sub, final Path expected, final Path actual) throws IOException {
		final int length = 4096;
		final byte[] hereBuffer = new byte[length];
		final byte[] thereBuffer = new byte[length];
		long hereLimit = 0;
		long thereLimit = 0;
		try(InputStream hereStream = newInputStream(expected); InputStream thereStream = newInputStream(actual)) {
			int line = 1;
			int ch = 0;
			for(long i = 0; i < Files.size(expected); i++) {
				if(i >= hereLimit) {
					hereLimit += read(hereStream, hereBuffer, hereLimit);
				}
				if(i >= thereLimit) {
					thereLimit += read(thereStream, thereBuffer, thereLimit);
				}
				final int c = hereBuffer[(int) (i % length)];
				assertThat(thereBuffer[(int) (i % length)], asserts(message(sub, i, line, ch), t -> t == c));
				if(c == '\n') {
					ch = 0;
					line++;
				} else {
					ch++;
				}
			}
		}
	}
1296911
def is_simple(fun):
    """"""
    seen_load_fast_0 = False
    seen_load_response = False
    seen_call_fun = False

    for instruction in dis.get_instructions(fun):
        if instruction.opname == 'LOAD_FAST' and instruction.arg == 0:
            seen_load_fast_0 = True
            continue

        if instruction.opname == 'LOAD_ATTR' \
           and instruction.argval == 'Response':
            seen_load_response = True
            continue

        if instruction.opname.startswith('CALL_FUNCTION'):
            if seen_call_fun:
                return False

            seen_call_fun = True
            continue

    return seen_call_fun and seen_load_fast_0 and seen_load_response
810936
public <T> void assertThat(T actual, org.hamcrest.Matcher<? super T> matcher) {
    try {
      org.hamcrest.MatcherAssert.assertThat(actual, matcher);
    } catch (AssertionError e) {
      fail(e);
    }
  }
177815
def assert_valid(self, instance, value=None):
        """"""
        valid = super(Instance, self).assert_valid(instance, value)
        if not valid:
            return False
        if value is None:
            value = instance._get(self.name)
        if isinstance(value, HasProperties):
            value.validate()
        return True
324668
function (match) {
        assertType(match, Function);

        for (var i = 0, len = this.length; i < len; i++) {
            if (match(this[i]) === false) {
                return false;
            }
        }

        return true;
    }
559782
def verify(x, t, y, pi, errorOnFail=True):
    
    # Unpack the proof
    p,c,u = pi

    # Verify types
    assertType(x, G1Element)
    assertType(y, GtElement)
    assertType(p, G1Element)
    assertScalarType(c)
    assertScalarType(u)

    # TODO: beta can be pre-computed while waiting for a server response.
    Q = generatorG1()
    beta = pair(x,hashG2(t))

    # Recompute c'
    t1 = Q*u + p*c 
    t2 = beta**u * y**c

    t1.normalize()

    cPrime = hashZ(Q,p,beta,y,t1,t2)

    # Check computed @c' against server's value @c
    if cPrime == c:
        return True

    if errorOnFail:
        raise Exception("zero-knowledge proof failed verification.")
    else:
        return False
63283
public static <S> void assertThat(S subject, Feature<? super S,Boolean> feature) {
        assertThat(subject, feature, isQuietlyTrue());
    }
361019
def _assert_same(values):
    """"""
    assert len(values) > 0
    first, rest = values[0], values[1:]
    for v in rest:
        assert v == first
    return first
149947
def assertit(self):
        """"""
        data = clips.data.DataObject(self._env)
        data.value = list(self._multifield)

        if lib.EnvPutFactSlot(
                self._env, self._fact, ffi.NULL, data.byref) != 1:
            raise CLIPSError(self._env)

        super(ImpliedFact, self).assertit()
579750
def assert_bool(dist, attr, value):
    """"""
    if bool(value) != value:
        raise DistutilsSetupError(
            "%r must be a boolean value (got %r)" % (attr,value)
        )