/** * Accuracy test for the method <code>getCountry()</code>.<br> * The value should be properly retrieved. */ @Test public void test_getCountry() { Country value = new Country(); instance.setCountry(value); assertSame("'getCountry' should be correct.", value, instance.getCountry()); }
/** * Accuracy test for the method <code>getStreet1()</code>.<br> * The value should be properly retrieved. */ @Test public void test_getStreet1() { String value = "new_value"; instance.setStreet1(value); assertEquals("'getStreet1' should be correct.", value, instance.getStreet1()); }
private static List<Address> parseResults( final int maxResults, final boolean parseAddressComponents, @NonNull final JSONObject o) throws JSONException { final JSONArray results = o.getJSONArray(RESULTS); final int count = results.length() >= maxResults ? maxResults : results.length(); final ArrayList<Address> addressList = new ArrayList<>(count); for (int i = 0; i < count; i++) { final Address address = new Address(); final JSONObject result = results.getJSONObject(i); if (result.has(FORMATTED_ADDRESS)) { address.setFormattedAddress(result.getString(FORMATTED_ADDRESS)); } parseGeometry(result, address); if (parseAddressComponents) { parseAddressComponents(result, address); } addressList.add(address); } return addressList; }
/* ------------------------------------------------------------ */ public void startConnection(HttpDestination destination) throws IOException { SocketChannel channel = null; try { channel = SocketChannel.open(); Address address = destination.isProxied() ? destination.getProxy() : destination.getAddress(); channel.socket().setTcpNoDelay(true); if (_httpClient.isConnectBlocking()) { channel.socket().connect(address.toSocketAddress(), _httpClient.getConnectTimeout()); channel.configureBlocking(false); _selectorManager.register(channel, destination); } else { channel.configureBlocking(false); channel.connect(address.toSocketAddress()); _selectorManager.register(channel, destination); ConnectTimeout connectTimeout = new ConnectTimeout(channel, destination); _httpClient.schedule(connectTimeout, _httpClient.getConnectTimeout()); _connectingChannels.put(channel, connectTimeout); } } catch (UnresolvedAddressException ex) { if (channel != null) channel.close(); destination.onConnectionFailed(ex); } catch (IOException ex) { if (channel != null) channel.close(); destination.onConnectionFailed(ex); } }
/** * ******************************************************************** * * @param the object that will remove an old association * @param the object that will be removed as the old association (neighbor) * ******************************************************************** */ public synchronized void deleteAssociation( Address address, Object neighbor, String AssociationID) { try { Address object = Database.get(Address.class, address.ID()); if (object != null) { int oldID = address.ID(); if (neighbor instanceof Station) { ((Station) neighbor).deleteAssociation(object, AssociationID); Transactions.AddCommand( new Command( getAccess(), CommandType.DELETE_ASSOCIATION, CommandTargetLayer.VIEW, oldID, address, object, Station.class, ((Station) neighbor).ID(), neighbor, null)); } object.checkModelRestrictions(); object.checkRestrictions(); Transactions.getSession().store(object); } else { Transactions.CancelTransaction( "Failed in DeleteAssociation", "the Address does not exists"); } } catch (Exception e) { Transactions.CancelTransaction( "Failed in DeleteAssociation", "Error ocurred while trying to delete the association of Address"); } }
@Override public void serializeContent(XmlSerializer serializer) throws IOException { if (isEmpty()) return; SerializerUtils.addTextTag(serializer, VCardProperty.FN.toString(), getFormattedName()); serializer.startTag(null, N_NAME); for (Entry<NameProperty, String> entry : name.entrySet()) SerializerUtils.addTextTag(serializer, entry.getKey().toString(), entry.getValue()); serializer.endTag(null, N_NAME); for (Entry<VCardProperty, String> entry : properties.entrySet()) if (entry.getKey() != VCardProperty.FN) SerializerUtils.addTextTag(serializer, entry.getKey().toString(), entry.getValue()); for (Photo photo : photos) photo.serialize(serializer); for (Address address : addresses) address.serialize(serializer); for (Label label : labels) label.serialize(serializer); for (Telephone telephone : telephones) telephone.serialize(serializer); for (Email email : emails) email.serialize(serializer); for (Logo logo : logos) logo.serialize(serializer); for (Sound sound : sounds) sound.serialize(serializer); for (Geo geo : geos) geo.serialize(serializer); for (Organization organization : organizations) organization.serialize(serializer); if (!categories.isEmpty()) { serializer.startTag(null, CATEGORIES_NAME); for (String keyword : categories) SerializerUtils.addTextTag(serializer, KEYWORD_NAME, keyword); serializer.endTag(null, CATEGORIES_NAME); } if (classification != null) SerializerUtils.addTextTag(serializer, CLASS_NAME, classification.toString()); for (Key key : keys) key.serialize(serializer); }
public void testUpdateUser() throws Exception { User user = dao.get(1L); Address address = user.getAddress(); address.setAddress1("new address"); user.setTimeZone("US/Central"); dao.saveUser(user); user = dao.get(1L); assertEquals(address, user.getAddress()); assertEquals("new address", user.getAddress().getAddress1()); assertEquals("US/Central", user.getTimeZone()); // verify that violation occurs when adding new user with same username user.setId(null); endTransaction(); try { dao.saveUser(user); // flush(); fail("saveUser didn't throw DataIntegrityViolationException"); } catch (DataIntegrityViolationException e) { assertNotNull(e); log.debug("expected exception: " + e.getMessage()); } }
@Test public void testMapping() throws Exception { Address address = new Address(); address.setStreet1("3340 Peachtree Rd NE"); address.setStreet2("JBoss"); FullTextSession s = Search.getFullTextSession(openSession()); Transaction tx = s.beginTransaction(); s.persist(address); tx.commit(); s.clear(); tx = s.beginTransaction(); QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer); org.apache.lucene.search.Query luceneQuery = parser.parse("" + address.getAddressId()); FullTextQuery query = s.createFullTextQuery(luceneQuery); assertEquals("documentId does not work properly", 1, query.getResultSize()); luceneQuery = parser.parse("street1:peachtree"); query = s.createFullTextQuery(luceneQuery).setProjection("idx_street2", FullTextQuery.THIS); assertEquals("Not properly indexed", 1, query.getResultSize()); Object[] firstResult = (Object[]) query.list().get(0); assertEquals("@Field.store not respected", "JBoss", firstResult[0]); // Verify that AddressClassBridge was applied as well: luceneQuery = parser.parse("AddressClassBridge:Applied\\!"); assertEquals(1, s.createFullTextQuery(luceneQuery).getResultSize()); s.delete(firstResult[1]); tx.commit(); s.close(); }
public Address buildShippingAddress(ShippingAddress sa) { Address address = new Address(); StringBuilder sb = new StringBuilder(1024); String CRLF = "\r\n"; sb.append(sa.getStreet()).append(CRLF); if (sa.getStreet2() != null) { sb.append(sa.getStreet2()).append(CRLF); } sb.append(sa.getPostalCode()).append(' '); sb.append(sa.getCity()); if (sa.getState() != null) { sb.append(' ').append(sa.getState()); } sb.append(CRLF); sb.append(sa.getCountryName()); if (sa.getPhone() != null) { sb.append(" Tel: ").append(sa.getPhone()); } address.setAddress(sb.toString()); address.setName(sa.getName()); return address; }
/** Execute when new member join or leave Group */ public void viewAccepted(View v) { memberSize = v.size(); if (mainFrame != null) setTitle(); members.clear(); members.addAll(v.getMembers()); if (v instanceof MergeView) { System.out.println("** " + v); // This is a simple merge function, which fetches the state from the coordinator // on a merge and overwrites all of its own state if (useState && !members.isEmpty()) { Address coord = members.get(0); Address local_addr = channel.getAddress(); if (local_addr != null && !local_addr.equals(coord)) { try { // make a copy of our state first Map<Point, Color> copy = null; if (send_own_state_on_merge) { synchronized (drawPanel.state) { copy = new LinkedHashMap<Point, Color>(drawPanel.state); } } System.out.println("fetching state from " + coord); channel.getState(coord, 5000); if (copy != null) sendOwnState(copy); // multicast my own state so everybody else has it too } catch (Exception e) { e.printStackTrace(); } } } } else System.out.println("** View=" + v); }
private static void deleteKey() { String pubkey = (String) options.valueOf("pubkey"); String addr = (String) options.valueOf("addr"); if (pubkey == null && addr == null) { System.err.println("One of --pubkey or --addr must be specified."); return; } ECKey key = null; if (pubkey != null) { key = wallet.findKeyFromPubKey(Hex.decode(pubkey)); } else { try { Address address = new Address(wallet.getParams(), addr); key = wallet.findKeyFromPubHash(address.getHash160()); } catch (AddressFormatException e) { System.err.println( addr + " does not parse as a Bitcoin address of the right network parameters."); return; } } if (key == null) { System.err.println("Wallet does not seem to contain that key."); return; } wallet.removeKey(key); }
private void setAddress() { Address addy = new Address(id); street = addy.getStreet(); district = addy.getDistrict(); city = addy.getCity(); province = addy.getProvince(); }
public void setBody(ByteBuffer buffer) throws NotEnoughDataInByteBufferException, TerminatingZeroNotFoundException, PDUException { setServiceType(buffer.removeCString()); setMessageId(buffer.removeCString()); sourceAddr.setData(buffer); // ? destAddr.setData(buffer); // ? }
public OopHandle getOopHandle(int x) { Address oopAddr = getOopHandleAddress(x); if (oopAddr != null) { return oopAddr.getOopHandleAt(0); } return null; }
protected void setup() { // save current null values for later restoration saveDefaultDefaultNullValues = ConversionManager.getDefaultManager().getDefaultNullValues(); saveDefaultNullValues = getSession().getLogin().getPlatform().getConversionManager().getDefaultNullValues(); getSession() .getLogin() .getPlatform() .getConversionManager() .setDefaultNullValues(new Hashtable()); getSession().getLogin().setDefaultNullValue(String.class, "null"); getSession().getLogin().setDefaultNullValue(int.class, new Integer(-1)); // Reinit mappings. for (DatabaseMapping mapping : getSession().getDescriptor(Address.class).getMappings()) { if (mapping.isDirectToFieldMapping()) { mapping.preInitialize(getAbstractSession()); } } getAbstractSession().beginTransaction(); employee = new Employee(); employee.setFirstName("Fred"); employee.setLastName("Flintstone"); employee.setSalary(22); employee.setGender("Male"); Address address = new Address(); address.setCity(null); employee.setAddress(address); getAbstractSession().writeObject(employee); // force the salary to be NULL getSession() .executeNonSelectingCall( new SQLCall("update SALARY set SALARY = null where EMP_ID = " + employee.getId())); }
@Test public void testBridgeMapping() throws Exception { Address address = new Address(); address.setStreet1("Peachtree Rd NE"); address.setStreet2("JBoss"); FullTextSession s = Search.getFullTextSession(openSession()); Transaction tx = s.beginTransaction(); s.persist(address); tx.commit(); s.clear(); tx = s.beginTransaction(); QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer); org.apache.lucene.search.Query luceneQuery = parser.parse("street1:peac"); FullTextQuery query = s.createFullTextQuery(luceneQuery); assertEquals("PrefixQuery should not be on", 0, query.getResultSize()); luceneQuery = parser.parse("street1_abridged:peac"); query = s.createFullTextQuery(luceneQuery); assertEquals("Bridge not used", 1, query.getResultSize()); s.delete(query.list().get(0)); tx.commit(); s.close(); }
/** * Test whether a memory range is set to a given integer value * * @param start The address to start checking at * @param bytes The size of the region to check, in bytes * @param verbose If true, produce verbose output * @param value The value to which the memory should be set */ private static boolean isSet(Address start, int bytes, boolean verbose, int value) /* Inlining this loop into the uninterruptible code can * cause/encourage the GCP into moving a get_obj_tib into the * interruptible region where the tib is being installed via an * int_store */ throws NoInlinePragma { if (Assert.VERIFY_ASSERTIONS) assertAligned(bytes); for (int i = 0; i < bytes; i += BYTES_IN_INT) if (start.loadInt(Offset.fromInt(i)) != value) { if (verbose) { Log.prependThreadId(); Log.write("Memory range does not contain only value "); Log.writeln(value); Log.write("Non-zero range: "); Log.write(start); Log.write(" .. "); Log.writeln(start.add(bytes)); Log.write("First bad value at "); Log.writeln(start.add(i)); dumpMemory(start, 0, bytes); } return false; } return true; }
@BeforeClass(dependsOnMethods = "init") public void initData() { EntityManager em = getEntityManager(); pc_id = 1l; a1_id = 10l; a2_id = 100l; // Rev 1 em.getTransaction().begin(); PersonalContact pc = new PersonalContact(pc_id, "e", "f"); Address a1 = new Address(a1_id, "a1"); a1.setContact(pc); em.persist(pc); em.persist(a1); em.getTransaction().commit(); // Rev 2 em.getTransaction().begin(); pc = em.find(PersonalContact.class, pc_id); Address a2 = new Address(a2_id, "a2"); a2.setContact(pc); em.persist(a2); em.getTransaction().commit(); }
@Inline private boolean acquireRecyclableBlockAddressOrder() { if (recyclableExhausted) { if (VM.VERIFY_ASSERTIONS && Options.verbose.getValue() >= 9) { Log.writeln("[no recyclable available]"); } return false; } int markState = 0; boolean usable = false; while (!usable) { Address next = recyclableBlock.plus(BYTES_IN_BLOCK); if (recyclableBlock.isZero() || ImmixSpace.isRecycleAllocChunkAligned(next)) { recyclableBlock = space.acquireReusableBlocks(); if (recyclableBlock.isZero()) { recyclableExhausted = true; if (VM.VERIFY_ASSERTIONS && Options.verbose.getValue() >= 9) { Log.writeln("[recyclable exhausted]"); } line = LINES_IN_BLOCK; return false; } } else { recyclableBlock = next; } markState = Block.getBlockMarkState(recyclableBlock); usable = (markState > 0 && markState <= ImmixSpace.getReusuableMarkStateThreshold(copy)); if (copy && Block.isDefragSource(recyclableBlock)) usable = false; } if (VM.VERIFY_ASSERTIONS) VM.assertions._assert(!Block.isUnused(recyclableBlock)); Block.setBlockAsReused(recyclableBlock); lineUseCount += (LINES_IN_BLOCK - markState); return true; // found something good }
/** * Invoked upon receiving a MERGE event from the MERGE layer. Starts the merge protocol. See * description of protocol in DESIGN. * * @param views A List of <em>different</em> views detected by the merge protocol */ public void merge(Map<Address, View> views) { if (isMergeInProgress()) { if (log.isTraceEnabled()) log.trace(gms.local_addr + ": merge is already running (merge_id=" + merge_id + ")"); return; } // we need the merge *coordinators* not merge participants because not everyone can lead a merge // ! Collection<Address> coords = Util.determineMergeCoords(views); Collection<Address> merge_participants = Util.determineMergeParticipants(views); Membership tmp = new Membership(coords); // establish a deterministic order, so that coords can elect leader tmp.sort(); Address merge_leader = tmp.elementAt(0); if (log.isDebugEnabled()) log.debug("determining merge leader from " + merge_participants); if (merge_leader.equals(gms.local_addr)) { if (log.isDebugEnabled()) log.debug( "I (" + gms.local_addr + ") will be the leader. Starting the merge task for " + merge_participants); merge_task.start(views); } else { if (log.isDebugEnabled()) log.debug( "I (" + gms.local_addr + ") am not the merge leader, " + "waiting for merge leader (" + merge_leader + ") to initiate merge"); } }
public void sendGetMembersRequest(String cluster_name, Promise promise, boolean return_views_only) throws Exception { PhysicalAddress physical_addr = (PhysicalAddress) down_prot.down(new Event(Event.GET_PHYSICAL_ADDRESS, local_addr)); PingData data = new PingData(local_addr, null, false, UUID.get(local_addr), Arrays.asList(physical_addr)); PingHeader hdr = new PingHeader(PingHeader.GET_MBRS_REQ, data, cluster_name); hdr.return_view_only = return_views_only; Set<PhysicalAddress> combined_target_members = new HashSet<PhysicalAddress>(initial_hosts); combined_target_members.addAll(dynamic_hosts); for (final Address addr : combined_target_members) { if (addr.equals(physical_addr)) continue; final Message msg = new Message(addr, null, null); msg.setFlag(Message.OOB); msg.putHeader(this.id, hdr); if (log.isTraceEnabled()) log.trace("[FIND_INITIAL_MBRS] sending PING request to " + msg.getDest()); timer.execute( new Runnable() { public void run() { try { down_prot.down(new Event(Event.MSG, msg)); } catch (Exception ex) { if (log.isErrorEnabled()) log.error("failed sending discovery request to " + addr + ": " + ex); } } }); } }
@RequestMapping(value = "/address/create", method = RequestMethod.POST) public String create(@ModelAttribute("addressAttribute") AddressForm addressForm, Model model) { logger.debug("Request to create new address"); // !!! necessary to check the existence of records in directories Address address = new Address(); AddressComplex addressComplex = new AddressComplex( addressForm.getCountry(), addressForm.getCity(), addressForm.getStreet(), addressForm.getBuild()); addressComplexService.create(addressComplex); address.setAddressComplex(addressComplex); Phone phone = new Phone(addressForm.getPhone()); phoneService.create(phone); address.setPhoneByIdPhone(phone); addressService.create(address); model.addAttribute("addressAll", addressService.getListAll()); // model.addAttribute("countryList", countryService.getList()); return "address"; // return "addedpage"; }
/** * Accuracy test for the method <code>getState()</code>.<br> * The value should be properly retrieved. */ @Test public void test_getState() { State value = new State(); instance.setState(value); assertSame("'getState' should be correct.", value, instance.getState()); }
private FromHeader getFromHeader() throws IOException { if (fromHeader != null) { return fromHeader; } try { SipURI fromURI = (SipURI) addressFactory.createURI("sip:" + proxyCredentials.getUserName() + "@" + registrar); fromURI.setTransportParam(sipProvider.getListeningPoint().getTransport()); fromURI.setPort(sipProvider.getListeningPoint().getPort()); Address fromAddress = addressFactory.createAddress(fromURI); fromAddress.setDisplayName(proxyCredentials.getUserDisplay()); fromHeader = headerFactory.createFromHeader(fromAddress, Integer.toString(hashCode())); } catch (ParseException e) { throw new IOException( "A ParseException occurred while creating From Header! " + e.getMessage()); } return fromHeader; }
@Test public void testAnalyzerDef() throws Exception { Address address = new Address(); address.setStreet1("3340 Peachtree Rd NE"); address.setStreet2("JBoss"); FullTextSession s = Search.getFullTextSession(openSession()); Transaction tx = s.beginTransaction(); s.persist(address); tx.commit(); s.clear(); tx = s.beginTransaction(); QueryParser parser = new QueryParser("id", TestConstants.standardAnalyzer); org.apache.lucene.search.Query luceneQuery = parser.parse("street1_ngram:pea"); final FullTextQuery query = s.createFullTextQuery(luceneQuery); assertEquals("Analyzer inoperant", 1, query.getResultSize()); s.delete(query.list().get(0)); tx.commit(); s.close(); }
protected void deliver(Message msg, Event evt, SequencerHeader hdr) { Address sender = msg.getSrc(); if (sender == null) { if (log.isErrorEnabled()) log.error(local_addr + ": sender is null, cannot deliver " + "::" + hdr.getSeqno()); return; } long msg_seqno = hdr.getSeqno(); if (sender.equals(local_addr)) { forward_table.remove(msg_seqno); if (hdr.flush_ack) { ack_promise.setResult(msg_seqno); if (ack_mode && !flushing && threshold > 0 && ++num_acks >= threshold) { ack_mode = false; num_acks = 0; } } } if (!canDeliver(sender, msg_seqno)) { if (log.isWarnEnabled()) log.warn(local_addr + ": dropped duplicate message " + sender + "::" + msg_seqno); return; } if (log.isTraceEnabled()) log.trace(local_addr + ": delivering " + sender + "::" + msg_seqno); up_prot.up(evt); delivered_bcasts++; }
@Test public void toStringTest() { InMemoryPrivateKey priv = new InMemoryPrivateKey(RANDOM_SOURCE); PublicKey pub = priv.getPublicKey(); Address addr = Address.fromStandardPublicKey(pub, NetworkParameters.productionNetwork); System.out.println(addr.toString()); }
@Test public void testProxyMethod() { Datastore ds = new RedisDatastore(); ds.getMappingContext().addPersistentEntity(Person.class); Session conn = ds.connect(); Person p = new Person(); p.setName("Bob"); Address a = new Address(); a.setNumber("22"); a.setPostCode("308420"); p.setAddress(a); conn.persist(p); Person personProxy = (Person) conn.proxy(Person.class, p.getId()); EntityProxy proxy = (EntityProxy) personProxy; assertFalse(proxy.isInitialized()); assertEquals(p.getId(), personProxy.getId()); assertFalse(proxy.isInitialized()); assertEquals("Bob", personProxy.getName()); assertTrue(proxy.isInitialized()); }
public static Address readConfig(InputStream in) { Address address = new Address(); try { // First create a new XMLInputFactory XMLInputFactory inputFactory = XMLInputFactory.newInstance(); // Setup a new eventReader // InputStream in = new FileInputStream(configFile); XMLEventReader eventReader = inputFactory.createXMLEventReader(in); // Read the XML document while (eventReader.hasNext()) { XMLEvent event = eventReader.nextEvent(); if (event.isStartElement()) { if (event.asStartElement().getName().getLocalPart() == ("country")) { event = eventReader.nextEvent(); address.setCountry(event.asCharacters().getData()); continue; } if (event.asStartElement().getName().getLocalPart() == ("county")) { event = eventReader.nextEvent(); address.setCity(event.asCharacters().getData()); continue; } } } } catch (XMLStreamException e) { e.printStackTrace(); } return address; }
@Override public void setRecipients(RecipientType type, Address[] addresses) throws MessagingException { if (type == RecipientType.TO) { if (addresses == null || addresses.length == 0) { removeHeader("To"); this.mTo = null; } else { setHeader("To", Address.toEncodedString(addresses)); this.mTo = addresses; } } else if (type == RecipientType.CC) { if (addresses == null || addresses.length == 0) { removeHeader("CC"); this.mCc = null; } else { setHeader("CC", Address.toEncodedString(addresses)); this.mCc = addresses; } } else if (type == RecipientType.BCC) { if (addresses == null || addresses.length == 0) { removeHeader("BCC"); this.mBcc = null; } else { setHeader("BCC", Address.toEncodedString(addresses)); this.mBcc = addresses; } } else { throw new MessagingException("Unrecognized recipient type."); } }