{ a1 = new A(); a2 = a1.foo1(); (System.printS("Null pointer coming!")); i1 = a2.geti1(); // error en tiempo de ejecucion }
@Override public boolean equals(final Object obj) { if (this == obj) { return true; } if (!Association.class.isInstance(obj)) { return false; } try { @SuppressWarnings("unchecked") Association<K, L, A, M, D> other = (Association<K, L, A, M, D>) obj; A other_a = other.getAntecendent(); A this_a = this.getAntecendent(); if (this_a == other_a || (this_a != null && this_a.equals(other_a))) { D other_d = other.getDependent(); D this_d = this.getDependent(); if (this_d == other_d || (this_d != null && this_d.equals(other_d))) { return true; } } } catch (ClassCastException ex) { return false; } return false; }
/** * Test that the contents of an allele-list are the ones expected. * * <p> * * <p>This method perform various consistency check involving all the {@link * org.broadinstitute.gatk.utils.genotyper.AlleleList} interface methods. Therefore calling this * method is equivalent to a thorough check of the {@link * org.broadinstitute.gatk.utils.genotyper.AlleleList} aspect of the {@code actual} argument. * * @param actual the sample-list to assess. * @param expected the expected sample-list. * @throws IllegalArgumentException if {@code expected} is {@code null} or contains {@code null}s * which is an indication of an bug in the testing code. * @throws RuntimeException if there is some testing assertion exception which is an indication of * an actual bug the code that is been tested. */ public static <A extends Allele> void assertAlleleList( final AlleleList<A> actual, final List<A> expected) { if (expected == null) throw new IllegalArgumentException("the expected list cannot be null"); final Set<A> expectedAlleleSet = new HashSet<>(expected.size()); Assert.assertNotNull(actual); Assert.assertEquals(actual.alleleCount(), expected.size()); for (int i = 0; i < expected.size(); i++) { final A expectedAllele = expected.get(i); if (expectedAllele == null) throw new IllegalArgumentException("the expected sample cannot be null"); if (expectedAllele.equals(NEVER_USE_ALLELE)) throw new IllegalArgumentException("you cannot use the forbidden sample name"); if (expectedAlleleSet.contains(expected.get(i))) throw new IllegalArgumentException( "repeated allele in the expected list, this is a test bug"); final A actualAllele = actual.alleleAt(i); Assert.assertNotNull(actualAllele, "allele cannot be null"); Assert.assertFalse( expectedAlleleSet.contains(actualAllele), "repeated allele: " + actualAllele); Assert.assertEquals(actualAllele, expectedAllele, "wrong allele order; index = " + i); Assert.assertEquals(actual.alleleIndex(actualAllele), i, "allele index mismatch"); expectedAlleleSet.add(actualAllele); } Assert.assertEquals(actual.alleleIndex((A) NEVER_USE_ALLELE), -1); }
public static void main(String[] args) { A a = new B(); B.a(); a.a(); // 输出结果是a,说明静态方法不能再子类之中被覆盖。 System.out.println(B.num); // 通过类名调用被覆盖的静态变量可以显示子类的被覆盖的静态变量。 System.out.println(a.num); // 输出2,说明静态变量是不能被在子类中被覆盖的。 }
@Ignore("alias property not supported yet") public void testBCollection() throws Exception { CompassSession session = openSession(); A a = new A(); a.id = 1; a.value = "value"; a.bs = new ArrayList<B>(); B b = new B(); b.value = "bvalue11"; b.value2 = "bvalue12"; a.bs.add(b); b = new B(); b.value = "bvalue21"; b.value = "bvalue22"; a.bs.add(b); session.save(a); Resource resource = session.loadResource(A.class, 1); assertNotNull(resource); assertEquals(7, resource.getProperties().length); assertEquals("A", resource.getAlias()); assertEquals(4, resource.getProperties("value").length); session.close(); }
public static void main(String[] args) { B b = new B(); b.aMethod(); A a = (A) b; a.aMethod(); }
@Ignore("alias property not supported yet") public void testBwoValues() throws Exception { CompassSession session = openSession(); A a = new A(); a.id = 1; a.value = "value"; B b = new B(); b.value = "bvalue"; b.value2 = "bvalue2"; a.b = b; session.save(a); Resource resource = session.loadResource(A.class, 1); assertNotNull(resource); assertEquals(6, resource.getProperties().length); assertEquals("A", resource.getAlias()); assertEquals(3, resource.getProperties("value").length); a = (A) session.load(A.class, 1); assertEquals(1, a.id.longValue()); assertNull(a.value); assertNull(a.b); session.close(); }
/** * Assert that the given object is lenient equals by ignoring null fields value on other object. * * @param info contains information about the assertion. * @param actual the given object. * @param other the object to compare {@code actual} to. * @throws NullPointerException if the actual type is {@code null}. * @throws NullPointerException if the other type is {@code null}. * @throws AssertionError if the actual and the given object are not lenient equals. * @throws AssertionError if the other object is not an instance of the actual type. */ public <A> void assertIsLenientEqualsToByIgnoringNullFields( AssertionInfo info, A actual, A other) { assertIsInstanceOf(info, other, actual.getClass()); List<String> fieldsNames = new LinkedList<String>(); List<Object> values = new LinkedList<Object>(); List<String> nullFields = new LinkedList<String>(); for (Field field : actual.getClass().getDeclaredFields()) { try { Object otherFieldValue = propertySupport.propertyValue(field.getName(), field.getType(), other); if (otherFieldValue != null) { Object actualFieldValue = propertySupport.propertyValue(field.getName(), field.getType(), actual); if (!otherFieldValue.equals(actualFieldValue)) { fieldsNames.add(field.getName()); values.add(otherFieldValue); } } else { nullFields.add(field.getName()); } } catch (IntrospectionError e) { // Not readeable field, skip. } } if (fieldsNames.isEmpty()) return; throw failures.failure( info, shouldBeLenientEqualByIgnoring(actual, fieldsNames, values, nullFields)); }
protected final <A extends Annotation> void assertAnnotation( PropertyInfo<?, ?> property, Class<A> annotationClass, Map<String, Object> expectedAnnotation) { A ann1 = property.getAnnotation(annotationClass); assertNotNull(ann1); Map<String, Object> values = new HashMap<String, Object>(); for (Method m : ann1.getClass().getDeclaredMethods()) { if (m.getName().equals("equals") && m.getParameterTypes().length == 1 && m.getParameterTypes()[0] == Object.class) { continue; } if (m.getName().equals("hashCode") && m.getParameterTypes().length == 0) { continue; } if (m.getName().equals("toString") && m.getParameterTypes().length == 0) { continue; } if (m.getName().equals("annotationType") && m.getParameterTypes().length == 0) { continue; } try { Object value = m.invoke(ann1); values.put(m.getName(), value); } catch (Exception e) { AssertionFailedError afe = new AssertionFailedError("Could not invoke annotation value " + m); afe.initCause(e); throw afe; } } assertEquals(expectedAnnotation, values); }
/** * Assert that the given object is lenient equals by ignoring fields. * * @param info contains information about the assertion. * @param actual the given object. * @param other the object to compare {@code actual} to. * @param fields the fields to ignore in comparison * @throws NullPointerException if the actual type is {@code null}. * @throws NullPointerException if the other type is {@code null}. * @throws AssertionError if the actual and the given object are not lenient equals. * @throws AssertionError if the other object is not an instance of the actual type. */ public <A> void assertIsLenientEqualsToByIgnoringFields( AssertionInfo info, A actual, A other, String... fields) { assertIsInstanceOf(info, other, actual.getClass()); List<String> fieldsNames = new LinkedList<String>(); List<Object> expectedValues = new LinkedList<Object>(); Set<String> ignoredFields = set(fields); for (Field field : actual.getClass().getDeclaredFields()) { try { if (!ignoredFields.contains(field.getName())) { String fieldName = field.getName(); Object actualFieldValue = propertySupport.propertyValue(fieldName, Object.class, actual); Object otherFieldValue = propertySupport.propertyValue(fieldName, Object.class, other); if (!org.fest.util.Objects.areEqual(actualFieldValue, otherFieldValue)) { fieldsNames.add(fieldName); expectedValues.add(otherFieldValue); } } } catch (IntrospectionError e) { // Not readeable field, skip. } } if (fieldsNames.isEmpty()) return; throw failures.failure( info, shouldBeLenientEqualByIgnoring(actual, fieldsNames, expectedValues, list(fields))); }
/** * Respond to the environment change and ensure that the neighbourhood best entities are updated. * This method (Template Method) calls two other methods in turn: * * <ul> * <li>{@link #performReaction(PopulationBasedAlgorithm)} * <li>{@link #updateNeighbourhoodBestEntities(Topology)} * </ul> * * @param algorithm some {@link PopulationBasedAlgorithm population based algorithm} */ public <P extends Particle, A extends SinglePopulationBasedAlgorithm<P>> void respond( A algorithm) { performReaction(algorithm); if (hasMemory) { updateNeighbourhoodBestEntities(algorithm.getTopology(), algorithm.getNeighbourhood()); } }
/** Test InlineEnclosure */ @Test public void autos6() { TestPage p = new TestPage(); p.setPageMarkup( "<div wicket:enclosure='a'><div wicket:id='a'></div><div wicket:id='b'></div></div>"); A a = new A(); B b = new B(); p.queue(a, b); tester.startPage(p); assertTrue(a.getParent() instanceof Enclosure); assertTrue(b.getParent() instanceof Enclosure); // A is visible, enclosure renders assertEquals( "<div wicket:enclosure=\"a\" id=\"wicket__InlineEnclosure_01\"><div wicket:id=\"a\"></div><div wicket:id=\"b\"></div></div>", tester.getLastResponseAsString()); // A is not visible, inline enclosure render only itself (the placeholder tag) a.setVisible(false); tester.startPage(p); assertEquals( "<div id=\"wicket__InlineEnclosure_01\" style=\"display:none\"></div>", tester.getLastResponseAsString()); }
public static void main(String[] args) throws IOException { A b = new B(); System.out.println(b.a); b.doSomethimg(); System.out.println(b.getA()); }
private void nowAttemptToUpdateRow() { Session s = sessionFactory().openSession(); s.beginTransaction(); try { // load with write lock to deal with databases that block (wait indefinitely) direct attempts // to write a locked row A it = (A) s.get( A.class, 1, new LockOptions(LockMode.PESSIMISTIC_WRITE).setTimeOut(LockOptions.NO_WAIT)); it.setValue("changed"); s.flush(); fail("Pessimistic lock not obtained/held"); } catch (Exception e) { // grr, exception can be any number of types based on database // see HHH-6887 if (LockAcquisitionException.class.isInstance(e) || GenericJDBCException.class.isInstance(e) || PessimisticLockException.class.isInstance(e)) { // "ok" } else { fail("Unexpected error type testing pessimistic locking : " + e.getClass().getName()); } } finally { s.getTransaction().rollback(); s.close(); } }
@Test public void autos5() { TestPage p = new TestPage(); p.setPageMarkup( "<wicket:enclosure child='a'><div wicket:id='a'></div><div wicket:id='b'></div></wicket:enclosure>"); A a = new A(); B b = new B(); p.queue(a); p.add(b); tester.startPage(p); assertTrue(a.getParent() instanceof Enclosure); assertTrue(b.getParent() instanceof TestPage); // A is visible, enclosure renders assertEquals( "<wicket:enclosure child=\"a\"><div wicket:id=\"a\"></div><div wicket:id=\"b\"></div></wicket:enclosure>", tester.getLastResponseAsString()); // A is not visible, enclosure does not render a.setVisible(false); tester.startPage(p); assertEquals("", tester.getLastResponseAsString()); }
public static void main(String args[]) { // create a new object a1 of the class A (value 3) A a1 = new A(); // create a new object a2 of the class A (value 3) A a2 = new A(); // increment the value of a1 by 1 (new value 4) a1.increment(); System.out.println(a1 + "/" + a2); // give all the settings of a1 to a2 a2 = a1; // increment the value of a2 by one (a2=a1, so the same for a1) a2.increment(); System.out.println(a1 + "/" + a2); // create a String s1 containing the uppercase word ROCK String s1 = "ROCK"; // create a String s2 and give it the same value (ROCK) String s2 = s1; // change the word "ROCK" in s2 to "rock" s2 = s2.toLowerCase(); System.out.println(s1 + "/" + s2); // create an int j with the value 1 int j = 1; // create an int i and give it the value of j int i = j; // increment the value of j by one j++; System.out.println(j + "/" + i); }
@Override public ClosestPair getClosestPair(A shapeA, Matrix4 transA, B shapeB, Matrix4 transB) { ClosestPair unjittered = wrapped.getClosestPair(shapeA, transA, shapeB, transB); if (unjittered != null) { // no jittering required to find a solution return unjittered; } else { // apply random jitters to one transform for (int i = 0; i < MAX_JITTERS; i++) { jitter.set( Math.random() * shapeA.getMargin(), Math.random() * shapeA.getMargin(), Math.random() * shapeA.getMargin()); jitteredTransform.set(transA); jitteredTransform.m03 += jitter.x; jitteredTransform.m13 += jitter.y; jitteredTransform.m23 += jitter.z; ClosestPair jittered = wrapped.getClosestPair(shapeA, jitteredTransform, shapeB, transB); if (jittered != null) { // remove any jittering from the two closest points // - since we translated the shape by jitter, the point in a // moves in the opposite direction of untranslating the shape // by jitter (which is just adding the jitter) Vector3 newPointOnA = new Vector3(jittered.getClosestPointOnA()).add(jitter); return new ClosestPair(newPointOnA, jittered.getContactNormal(), jittered.getDistance()); } } // jittering did not find a solution return null; } }
public static void main(String[] args) { A p = g(0, 5); p.f(); System.out.println("---"); p = g(2, 1); p.f(); }
@Override public boolean instantiateTo(int value, ICause cause, boolean informCause) throws ContradictionException { if (informCause) { cause = Cause.Null; } if (this.instantiated()) { if (value != this.getValue()) { this.contradiction(cause, MSG_INST); } return false; } else if (contains(value)) { // todo: delta this.LB.set(value); this.UB.set(value); this.SIZE.set(1); A.updateUpperBound(value, this, false); B.updateUpperBound(value, this, false); if (!A.contains(value)) { B.instantiateTo(value, this, false); } if (!B.contains(value)) { A.instantiateTo(value, this, false); } this.notifyPropagators(EventType.INSTANTIATE, cause); return true; } else { this.contradiction(cause, MSG_UNKNOWN); return false; } }
public static void main(String[] args) { A pa = g(); try { pa.f(); } catch (Exception1 e) { } }
public static void main(String args[]) { Pair p; p = new Pair(2, new Pair(88, null)); System.out.println(p.car()); System.out.println(p.cdr().car()); System.out.println(p.ww); System.out.println(p.yy); System.out.println(p.car); System.out.println(p.cdr.car); System.out.println(p.V4[0]); System.out.println(p.V4[1]); System.out.println(p.V3[0]); System.out.println(p.V3[1]); System.out.println(SpecialPair.w); System.out.println(SpecialPair.x); System.out.println(SpecialPair.V1[0]); System.out.println(SpecialPair.V1.length); System.out.println(A.fa()); A a = new A(); A[] va = new A[2]; System.out.println(a.fb()); System.out.println(a.w); // A strange case, should we generate code for va[0]? // System.out.println(va[0].w); }
public void testRepeatFactor() { RQ rq = new RQ(A.numRows(), A.numColumns()); rq.factor(new DenseMatrix(A)); assertEquals(A, rq); rq.factor(new DenseMatrix(A)); assertEquals(A, rq); }
public static void main(String[] args) { A a = new A(); A b = new A(); a.setI(41); b.setI(42); assert a.i != 41; }
public static void main(String[] args) { A a = new A(); a.set(new A()); a = a.set(new A()).get(); a = a.get(); C c = new C(); c = c.setAndGet(new C()); }
public Ecaille() { A.add(new Attribut("ResFroid", -10)); A.add(new Attribut("ResChaud", 10)); A.add(new Attribut("Combat", 10)); Nom = "Ecaille"; I.add(new Interdit("Plumage")); I.add(new Interdit("Fourrure")); }
public static void main(String[] args) { A ob = new B(); ob.AA(); // B ob1=new A(); //Error due to incompatible types as sub class cannot cast into super class // ob1.AA(); }
/** * @see * org.openmrs.customdatatype.Customizable#getActiveAttributes(org.openmrs.customdatatype.CustomValueDescriptor) */ @Override public java.util.List<A> getActiveAttributes(CustomValueDescriptor ofType) { List<A> ret = new ArrayList<A>(); if (getAttributes() != null) for (A attr : getAttributes()) if (attr.getAttributeType().equals(ofType) && !attr.isVoided()) ret.add(attr); return ret; }
public void testF() { A instance = new A(); instance.f(); String[] temp = outContent.toString().split(System.getProperty("line.separator")); assertEquals("A", temp[1]); // TODO review the generated test code and remove the default call to fail. // fail("The test case is a prototype."); }
private <A extends RestAction<?>> void buildBody(RequestBuilder requestBuilder, A action) throws ActionException { if (action.hasFormParams()) { requestBuilder.setRequestData(buildQueryString(action.getFormParams())); } else if (action.hasBodyParam()) { requestBuilder.setRequestData(getSerializedValue(action, action.getBodyParam())); } }
public static void main(String[] args) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException { A a = new A(); a.name = "yangliang"; B b = new B(); // BeanUtils.copyProperties(a, b); System.out.println(b.name); }