Add RdeParser

RdeParser can parse an escrow deposit file from a stream without
loading the entire file into memory, but offers the convenience
of parsing RDE elements into their jaxb object representation.
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=124142087

javatests/google/registry/rde/RdeParserTest.java

@@ -0,0 +1,482 @@
+// Copyright 2016 The Domain Registry Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package google.registry.rde;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.io.ByteSource;
+
+import google.registry.rde.RdeParser.RdeHeader;
+import google.registry.testing.ExceptionRule;
+import google.registry.xjc.rdecontact.XjcRdeContact;
+import google.registry.xjc.rdedomain.XjcRdeDomain;
+import google.registry.xjc.rdeeppparams.XjcRdeEppParams;
+import google.registry.xjc.rdehost.XjcRdeHost;
+import google.registry.xjc.rdeidn.XjcRdeIdn;
+import google.registry.xjc.rdenndn.XjcRdeNndn;
+import google.registry.xjc.rderegistrar.XjcRdeRegistrar;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/** Unit tests for {@link RdeParser}. */
+@RunWith(JUnit4.class)
+public class RdeParserTest {
+
+  private static final ByteSource DEPOSIT_XML = RdeTestData.get("deposit_full_parser.xml");
+
+  private InputStream xml;
+
+  @Rule
+  public final ExceptionRule thrown = new ExceptionRule();
+
+  private void checkHeader(RdeHeader header) {
+    assertThat(header.getTld()).isEqualTo("test");
+    assertThat(header.getContactCount()).isEqualTo(1L);
+    assertThat(header.getDomainCount()).isEqualTo(2L);
+    assertThat(header.getEppParamsCount()).isEqualTo(1L);
+    assertThat(header.getHostCount()).isEqualTo(1L);
+    assertThat(header.getIdnCount()).isEqualTo(1L);
+    assertThat(header.getNndnCount()).isEqualTo(1L);
+    assertThat(header.getRegistrarCount()).isEqualTo(1L);
+  }
+
+  @Before
+  public void before() throws IOException {
+    xml = new ByteArrayInputStream(DEPOSIT_XML.read());
+  }
+
+  @After
+  public void after() throws IOException {
+    xml.close();
+  }
+
+  @Test
+  public void testGetHeader_returnsHeader() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    checkHeader(parser.getHeader());
+  }
+
+  @Test
+  public void testGetContactNotAtElement_throwsIllegalStateException() throws Exception {
+    thrown.expect(IllegalStateException.class,
+        "Not at element urn:ietf:params:xml:ns:rdeContact-1.0:contact");
+    RdeParser parser = new RdeParser(xml);
+    parser.getContact();
+  }
+
+  @Test
+  public void testGetContactAtElement_returnsContact() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextContact();
+    XjcRdeContact contact = parser.getContact();
+    assertThat(contact.getId()).isEqualTo("sh8013");
+    assertThat(contact.getClID()).isEqualTo("RegistrarX");
+  }
+
+  @Test
+  public void testNextContact_advancesParser() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.isAtContact()).isFalse();
+    // there is only one contact in the escrow file
+    assertThat(parser.nextContact()).isTrue();
+    assertThat(parser.isAtContact()).isTrue();
+    assertThat(parser.nextContact()).isFalse();
+    assertThat(parser.isAtContact()).isFalse();
+  }
+
+  @Test
+  public void testSkipZeroContacts_skipsZero() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipContacts(0)).isEqualTo(0);
+    assertThat(parser.nextContact()).isTrue();
+  }
+
+  @Test
+  public void testSkipOneContactFromBeginning_skipsOne() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipContacts(1)).isEqualTo(1);
+    assertThat(parser.isAtContact()).isFalse();
+  }
+
+  @Test
+  public void testSkipOneContactFromFirstContact_skipsOne() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextContact();
+    assertThat(parser.skipContacts(1)).isEqualTo(1);
+    assertThat(parser.isAtContact()).isFalse();
+  }
+
+  @Test
+  public void testSkip9999Contacts_skipsOne() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipContacts(9999)).isEqualTo(1);
+    assertThat(parser.isAtContact()).isFalse();
+  }
+
+  @Test
+  public void testSkipContactsFromEnd_skipsZero() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextContact();
+    parser.nextContact();
+    assertThat(parser.skipContacts(1)).isEqualTo(0);
+    assertThat(parser.isAtContact()).isFalse();
+  }
+
+  @Test
+  public void testGetHeaderAfterNextContact_returnsHeader() throws Exception {
+    // verify that the header is still available after advancing to next contact
+    RdeParser parser = new RdeParser(xml);
+    parser.nextContact();
+    checkHeader(parser.getHeader());
+  }
+
+  @Test
+  public void testGetDomainNotAtElement_throwsIllegalStateException() throws Exception {
+    thrown.expect(IllegalStateException.class,
+        "Not at element urn:ietf:params:xml:ns:rdeDomain-1.0:domain");
+    RdeParser parser = new RdeParser(xml);
+    parser.getDomain();
+  }
+
+  @Test
+  public void testGetDomainAtElement_returnsDomain() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextDomain();
+    XjcRdeDomain domain = parser.getDomain();
+    assertThat(domain.getName()).isEqualTo("example1.test");
+  }
+
+  @Test
+  public void testNextDomain_advancesParser() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    // there are 2 domains in the escrow file
+    assertThat(parser.isAtDomain()).isFalse();
+    assertThat(parser.nextDomain()).isTrue();
+    assertThat(parser.isAtDomain()).isTrue();
+    assertThat(parser.nextDomain()).isTrue();
+    assertThat(parser.isAtDomain()).isTrue();
+    assertThat(parser.nextDomain()).isFalse();
+    assertThat(parser.isAtDomain()).isFalse();
+  }
+
+  @Test
+  public void testSkipZeroDomains_skipsZero() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipDomains(0)).isEqualTo(0);
+    assertThat(parser.nextDomain()).isTrue();
+  }
+
+  @Test
+  public void testSkipOneDomainFromBeginning_skipsOne() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipDomains(1)).isEqualTo(1);
+    // there are two domains
+    assertThat(parser.isAtDomain()).isTrue();
+    // prove that the parser advanced to the second domain
+    assertThat(parser.nextDomain()).isFalse();
+    assertThat(parser.isAtDomain()).isFalse();
+  }
+
+  @Test
+  public void testSkipTwoDomainsFromBeginning_skipsTwo() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipDomains(2)).isEqualTo(2);
+    // there are two domains
+    assertThat(parser.isAtDomain()).isFalse();
+  }
+
+  @Test
+  public void testSkipOneDomainFromFirstDomain_skipsOne() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextDomain();
+    assertThat(parser.skipDomains(1)).isEqualTo(1);
+    // there are two domains
+    assertThat(parser.isAtDomain()).isTrue();
+    // prove that the parser advanced to the second domain
+    assertThat(parser.nextDomain()).isFalse();
+    assertThat(parser.isAtDomain()).isFalse();
+  }
+
+  @Test
+  public void testSkipTwoDomainsFromFirstDomain_skipsTwo() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextDomain();
+    assertThat(parser.skipDomains(2)).isEqualTo(2);
+    // there are two domains
+    assertThat(parser.isAtDomain()).isFalse();
+  }
+
+  @Test
+  public void testSkip9999Domains_skipsTwo() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipDomains(9999)).isEqualTo(2);
+    assertThat(parser.isAtDomain()).isFalse();
+  }
+
+  @Test
+  public void testSkipDomainsFromEnd_skipsZero() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextDomain();
+    parser.nextDomain();
+    parser.nextDomain();
+    assertThat(parser.skipDomains(1)).isEqualTo(0);
+  }
+
+  @Test
+  public void testGetHeaderAfterNextDomain_returnsHeader() throws Exception {
+    // verify that the header is still available after advancing to next domain
+    RdeParser parser = new RdeParser(xml);
+    parser.nextDomain();
+    checkHeader(parser.getHeader());
+  }
+
+  @Test
+  public void testGetHostNotAtElement_throwsIllegalStateException() throws Exception {
+    thrown.expect(IllegalStateException.class,
+        "Not at element urn:ietf:params:xml:ns:rdeHost-1.0:host");
+    RdeParser parser = new RdeParser(xml);
+    parser.getHost();
+  }
+
+  @Test
+  public void testGetHostAtElement_returnsHost() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextHost();
+    XjcRdeHost host = parser.getHost();
+    assertThat(host.getName()).isEqualTo("ns1.example.com");
+  }
+
+  @Test
+  public void testNextHost_advancesParser() throws Exception {
+    // the header lies, there are 2 hosts in the file
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.isAtHost()).isFalse();
+    assertThat(parser.nextHost()).isTrue();
+    assertThat(parser.isAtHost()).isTrue();
+    assertThat(parser.nextHost()).isTrue();
+    assertThat(parser.isAtHost()).isTrue();
+    assertThat(parser.nextHost()).isFalse();
+    assertThat(parser.isAtHost()).isFalse();
+  }
+
+  @Test
+  public void testSkipZeroHosts_skipsZero() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipHosts(0)).isEqualTo(0);
+    assertThat(parser.nextHost()).isTrue();
+  }
+
+  @Test
+  public void testSkipOneHostFromBeginning_skipsOne() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipHosts(1)).isEqualTo(1);
+    // there are two hosts
+    assertThat(parser.isAtHost()).isTrue();
+    // prove that the parser advanced to the second host
+    assertThat(parser.nextHost()).isFalse();
+    assertThat(parser.isAtHost()).isFalse();
+  }
+
+  @Test
+  public void testSkipTwoHostsFromBeginning_skipsTwo() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipHosts(2)).isEqualTo(2);
+    // there are two hosts
+    assertThat(parser.isAtHost()).isFalse();
+  }
+
+  @Test
+  public void testSkipOneHostFromFirstHost_skipsOne() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextHost();
+    assertThat(parser.skipHosts(1)).isEqualTo(1);
+    // there are two hosts
+    assertThat(parser.isAtHost()).isTrue();
+    // prove that the parser advanced to the second host
+    assertThat(parser.nextHost()).isFalse();
+    assertThat(parser.isAtHost()).isFalse();
+  }
+
+  @Test
+  public void testSkipTwoHostsFromFirstHost_skipsTwo() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextHost();
+    assertThat(parser.skipHosts(2)).isEqualTo(2);
+    // there are two hosts
+    assertThat(parser.isAtHost()).isFalse();
+  }
+
+  @Test
+  public void testSkip9999Hosts_skipsTwo() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.skipHosts(9999)).isEqualTo(2);
+    // there are two hosts
+    assertThat(parser.isAtHost()).isFalse();
+  }
+
+  @Test
+  public void testSkipHostFromEnd_skipsZero() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextHost();
+    parser.nextHost();
+    parser.nextHost();
+    assertThat(parser.skipHosts(1)).isEqualTo(0);
+  }
+
+  @Test
+  public void testGetHeaderAfterNextHost_returnsHeader() throws Exception {
+    // verify that the header is still available after advancing to next host
+    RdeParser parser = new RdeParser(xml);
+    parser.nextHost();
+    checkHeader(parser.getHeader());
+  }
+
+  @Test
+  public void testGetRegistrarNotAtElement_throwsIllegalStateException() throws Exception {
+    thrown.expect(IllegalStateException.class,
+        "Not at element urn:ietf:params:xml:ns:rdeRegistrar-1.0:registrar");
+    RdeParser parser = new RdeParser(xml);
+    parser.getRegistrar();
+  }
+
+  @Test
+  public void testGetRegistrarAtElement_returnsRegistrar() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextRegistrar();
+    XjcRdeRegistrar registrar = parser.getRegistrar();
+    assertThat(registrar.getId()).isEqualTo("RegistrarX");
+    assertThat(registrar.getName()).isEqualTo("Registrar X");
+  }
+
+  @Test
+  public void testNextRegistrar_advancesParser() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.isAtRegistrar()).isFalse();
+    assertThat(parser.nextRegistrar()).isTrue();
+    assertThat(parser.isAtRegistrar()).isTrue();
+    assertThat(parser.nextRegistrar()).isFalse();
+    assertThat(parser.isAtRegistrar()).isFalse();
+  }
+
+  @Test
+  public void testGetHeaderAfterNextRegistrar_returnsHeader() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextRegistrar();
+    checkHeader(parser.getHeader());
+  }
+
+  @Test
+  public void testGetNndnNotAtElement_throwsIllegalStateException() throws Exception {
+    thrown.expect(IllegalStateException.class,
+        "Not at element urn:ietf:params:xml:ns:rdeNNDN-1.0:NNDN");
+    RdeParser parser = new RdeParser(xml);
+    parser.getNndn();
+  }
+
+  @Test
+  public void testGetNndnAtElement_returnsNndn() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextNndn();
+    XjcRdeNndn nndn = parser.getNndn();
+    assertThat(nndn.getAName()).isEqualTo("xn--exampl-gva.test");
+  }
+
+  @Test
+  public void testNextNndn_advancesParser() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.isAtNndn()).isFalse();
+    assertThat(parser.nextNndn()).isTrue();
+    assertThat(parser.isAtNndn()).isTrue();
+    assertThat(parser.nextNndn()).isFalse();
+    assertThat(parser.isAtNndn()).isFalse();
+  }
+
+  @Test
+  public void testGetHeaderAfterNextNndn_returnsHeader() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextNndn();
+    checkHeader(parser.getHeader());
+  }
+
+  @Test
+  public void testGetIdnNotAtElement_throwsIllegalStateException() throws Exception {
+    thrown.expect(IllegalStateException.class,
+        "Not at element urn:ietf:params:xml:ns:rdeIDN-1.0:idnTableRef");
+    RdeParser parser = new RdeParser(xml);
+    parser.getIdn();
+  }
+
+  @Test
+  public void testGetIdnAtElement_returnsIdn() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextIdn();
+    XjcRdeIdn idn = parser.getIdn();
+    // url contains whitespace
+    assertThat(idn.getUrl().trim())
+        .isEqualTo("http://www.iana.org/domains/idn-tables/tables/br_pt-br_1.0.html");
+  }
+
+  @Test
+  public void testNextIdn_advancesParser() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.isAtIdn()).isFalse();
+    assertThat(parser.nextIdn()).isTrue();
+    assertThat(parser.isAtIdn()).isTrue();
+    assertThat(parser.nextIdn()).isFalse();
+    assertThat(parser.isAtIdn()).isFalse();
+  }
+
+  @Test
+  public void testGetHeaderAfterNextIdn_returnsHeader() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextIdn();
+    checkHeader(parser.getHeader());
+  }
+
+  @Test
+  public void testGetEppParamsNotAtElement_throwsIllegalStateException() throws Exception {
+    thrown.expect(IllegalStateException.class,
+        "Not at element urn:ietf:params:xml:ns:rdeEppParams-1.0:eppParams");
+    RdeParser parser = new RdeParser(xml);
+    parser.getEppParams();
+  }
+
+  @Test
+  public void testGetEppParamsAtElement_returnsEppParams() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    parser.nextEppParams();
+    XjcRdeEppParams eppParams = parser.getEppParams();
+    assertThat(eppParams.getVersions()).containsExactly("1.0");
+  }
+
+  @Test
+  public void testNextEppParamsAdvancesParser() throws Exception {
+    RdeParser parser = new RdeParser(xml);
+    assertThat(parser.isAtEppParams()).isFalse();
+    assertThat(parser.nextEppParams()).isTrue();
+    assertThat(parser.isAtEppParams()).isTrue();
+    assertThat(parser.nextEppParams()).isFalse();
+    assertThat(parser.isAtEppParams()).isFalse();
+  }
+}

javatests/google/registry/rde/testdata/deposit_full_parser.xml

@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rde:deposit type="FULL" id="20101017001" prevId="20101010001"
+  xmlns:domain="urn:ietf:params:xml:ns:domain-1.0"
+  xmlns:contact="urn:ietf:params:xml:ns:contact-1.0"
+  xmlns:secDNS="urn:ietf:params:xml:ns:secDNS-1.1"
+  xmlns:rde="urn:ietf:params:xml:ns:rde-1.0"
+  xmlns:rdeHeader="urn:ietf:params:xml:ns:rdeHeader-1.0"
+  xmlns:rdeDom="urn:ietf:params:xml:ns:rdeDomain-1.0"
+  xmlns:rdeHost="urn:ietf:params:xml:ns:rdeHost-1.0"
+  xmlns:rdeContact="urn:ietf:params:xml:ns:rdeContact-1.0"
+  xmlns:rdeRegistrar="urn:ietf:params:xml:ns:rdeRegistrar-1.0"
+  xmlns:rdeIDN="urn:ietf:params:xml:ns:rdeIDN-1.0"
+  xmlns:rdeNNDN="urn:ietf:params:xml:ns:rdeNNDN-1.0"
+  xmlns:rdeEppParams="urn:ietf:params:xml:ns:rdeEppParams-1.0"
+  xmlns:rdePolicy="urn:ietf:params:xml:ns:rdePolicy-1.0"
+  xmlns:epp="urn:ietf:params:xml:ns:epp-1.0">
+
+  <rde:watermark>2010-10-17T00:00:00Z</rde:watermark>
+  <rde:rdeMenu>
+    <rde:version>1.0</rde:version>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeHeader-1.0</rde:objURI>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeContact-1.0</rde:objURI>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeHost-1.0</rde:objURI>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeDomain-1.0</rde:objURI>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeRegistrar-1.0</rde:objURI>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeIDN-1.0</rde:objURI>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeNNDN-1.0</rde:objURI>
+    <rde:objURI>urn:ietf:params:xml:ns:rdeEppParams-1.0</rde:objURI>
+  </rde:rdeMenu>
+
+  <!-- Contents -->
+  <rde:contents>
+    <!-- Header -->
+    <rdeHeader:header>
+      <rdeHeader:tld>test</rdeHeader:tld>
+      <rdeHeader:count
+        uri="urn:ietf:params:xml:ns:rdeDomain-1.0">2
+        </rdeHeader:count>
+      <rdeHeader:count
+        uri="urn:ietf:params:xml:ns:rdeHost-1.0">1
+        </rdeHeader:count>
+      <rdeHeader:count
+        uri="urn:ietf:params:xml:ns:rdeContact-1.0">1
+        </rdeHeader:count>
+      <rdeHeader:count
+        uri="urn:ietf:params:xml:ns:rdeRegistrar-1.0">1
+    </rdeHeader:count>
+      <rdeHeader:count
+        uri="urn:ietf:params:xml:ns:rdeIDN-1.0">1
+        </rdeHeader:count>
+      <rdeHeader:count
+        uri="urn:ietf:params:xml:ns:rdeNNDN-1.0">1
+        </rdeHeader:count>
+      <rdeHeader:count
+        uri="urn:ietf:params:xml:ns:rdeEppParams-1.0">1
+    </rdeHeader:count>
+    </rdeHeader:header>
+
+    <!-- Domain: example1.test -->
+    <rdeDom:domain>
+      <rdeDom:name>example1.test</rdeDom:name>
+      <rdeDom:roid>Dexample1-TEST</rdeDom:roid>
+      <rdeDom:status s="ok"/>
+      <rdeDom:registrant>jd1234</rdeDom:registrant>
+      <rdeDom:contact type="admin">sh8013</rdeDom:contact>
+      <rdeDom:contact type="tech">sh8013</rdeDom:contact>
+      <rdeDom:ns>
+        <domain:hostObj>ns1.example.com</domain:hostObj>
+        <domain:hostObj>ns1.example1.test</domain:hostObj>
+      </rdeDom:ns>
+      <rdeDom:clID>RegistrarX</rdeDom:clID>
+      <rdeDom:crRr client="jdoe">RegistrarX</rdeDom:crRr>
+      <rdeDom:crDate>1999-04-03T22:00:00.0Z</rdeDom:crDate>
+      <rdeDom:exDate>2015-04-03T22:00:00.0Z</rdeDom:exDate>
+    </rdeDom:domain>
+
+    <!-- Domain: example2.test -->
+    <rdeDom:domain>
+      <rdeDom:name>example2.test</rdeDom:name>
+      <rdeDom:roid>Dexample2-TEST</rdeDom:roid>
+      <rdeDom:status s="ok"/>
+      <rdeDom:status s="clientUpdateProhibited"/>
+      <rdeDom:registrant>jd1234</rdeDom:registrant>
+      <rdeDom:contact type="admin">sh8013</rdeDom:contact>
+      <rdeDom:contact type="tech">sh8013</rdeDom:contact>
+      <rdeDom:clID>RegistrarX</rdeDom:clID>
+      <rdeDom:crRr>RegistrarX</rdeDom:crRr>
+      <rdeDom:crDate>1999-04-03T22:00:00.0Z</rdeDom:crDate>
+      <rdeDom:exDate>2015-04-03T22:00:00.0Z</rdeDom:exDate>
+    </rdeDom:domain>
+
+    <!-- Host: ns1.example.com -->
+    <rdeHost:host>
+      <rdeHost:name>ns1.example.com</rdeHost:name>
+      <rdeHost:roid>Hns1_example_com-TEST</rdeHost:roid>
+      <rdeHost:status s="ok"/>
+      <rdeHost:status s="linked"/>
+      <rdeHost:addr ip="v4">192.0.2.2</rdeHost:addr>
+      <rdeHost:addr ip="v4">192.0.2.29</rdeHost:addr>
+      <rdeHost:addr ip="v6">1080:0:0:0:8:800:200C:417A
+      </rdeHost:addr>
+      <rdeHost:clID>RegistrarX</rdeHost:clID>
+      <rdeHost:crRr>RegistrarX</rdeHost:crRr>
+      <rdeHost:crDate>1999-05-08T12:10:00.0Z</rdeHost:crDate>
+      <rdeHost:upRr>RegistrarX</rdeHost:upRr>
+      <rdeHost:upDate>2009-10-03T09:34:00.0Z</rdeHost:upDate>
+    </rdeHost:host>
+
+    <!-- Host: ns1.example1.test -->
+    <rdeHost:host>
+      <rdeHost:name>ns1.example1.test</rdeHost:name>
+      <rdeHost:roid>Hns1_example1_test-TEST</rdeHost:roid>
+      <rdeHost:status s="ok"/>
+      <rdeHost:status s="linked"/>
+      <rdeHost:addr ip="v4">192.0.2.2</rdeHost:addr>
+      <rdeHost:addr ip="v4">192.0.2.29</rdeHost:addr>
+      <rdeHost:addr ip="v6">1080:0:0:0:8:800:200C:417A
+      </rdeHost:addr>
+      <rdeHost:clID>RegistrarX</rdeHost:clID>
+      <rdeHost:crRr>RegistrarX</rdeHost:crRr>
+      <rdeHost:crDate>1999-05-08T12:10:00.0Z</rdeHost:crDate>
+      <rdeHost:upRr>RegistrarX</rdeHost:upRr>
+      <rdeHost:upDate>2009-10-03T09:34:00.0Z</rdeHost:upDate>
+    </rdeHost:host>
+
+    <!-- Contact: sh8013 -->
+    <rdeContact:contact>
+      <rdeContact:id>sh8013</rdeContact:id>
+      <rdeContact:roid>Csh8013-TEST</rdeContact:roid>
+      <rdeContact:status s="linked"/>
+      <rdeContact:status s="clientDeleteProhibited"/>
+      <rdeContact:postalInfo type="int">
+        <contact:name>John Doe</contact:name>
+        <contact:org>Example Inc.</contact:org>
+        <contact:addr>
+          <contact:street>123 Example Dr.</contact:street>
+          <contact:street>Suite 100</contact:street>
+          <contact:city>Dulles</contact:city>
+          <contact:sp>VA</contact:sp>
+          <contact:pc>20166-6503</contact:pc>
+          <contact:cc>US</contact:cc>
+        </contact:addr>
+      </rdeContact:postalInfo>
+      <rdeContact:voice x="1234">+1.7035555555
+      </rdeContact:voice>
+      <rdeContact:fax>+1.7035555556
+      </rdeContact:fax>
+      <rdeContact:email>jdoe@example.test
+      </rdeContact:email>
+      <rdeContact:clID>RegistrarX</rdeContact:clID>
+      <rdeContact:crRr client="jdoe">RegistrarX
+      </rdeContact:crRr>
+      <rdeContact:crDate>2009-09-13T08:01:00.0Z</rdeContact:crDate>
+      <rdeContact:upRr client="jdoe">RegistrarX
+      </rdeContact:upRr>
+      <rdeContact:upDate>2009-11-26T09:10:00.0Z</rdeContact:upDate>
+      <rdeContact:trDate>2009-12-03T09:05:00.0Z</rdeContact:trDate>
+      <rdeContact:disclose flag="0">
+        <contact:voice/>
+        <contact:email/>
+      </rdeContact:disclose>
+    </rdeContact:contact>
+
+    <!-- Registrar: RegistrarX -->
+    <rdeRegistrar:registrar>
+      <rdeRegistrar:id>RegistrarX</rdeRegistrar:id>
+      <rdeRegistrar:name>Registrar X</rdeRegistrar:name>
+      <rdeRegistrar:gurid>123</rdeRegistrar:gurid>
+      <rdeRegistrar:status>ok</rdeRegistrar:status>
+      <rdeRegistrar:postalInfo type="int">
+        <rdeRegistrar:addr>
+          <rdeRegistrar:street>123 Example Dr.
+          </rdeRegistrar:street>
+          <rdeRegistrar:street>Suite 100
+          </rdeRegistrar:street>
+          <rdeRegistrar:city>Dulles</rdeRegistrar:city>
+          <rdeRegistrar:sp>VA</rdeRegistrar:sp>
+          <rdeRegistrar:pc>20166-6503</rdeRegistrar:pc>
+          <rdeRegistrar:cc>US</rdeRegistrar:cc>
+        </rdeRegistrar:addr>
+      </rdeRegistrar:postalInfo>
+      <rdeRegistrar:voice x="1234">+1.7035555555
+      </rdeRegistrar:voice>
+      <rdeRegistrar:fax>+1.7035555556
+      </rdeRegistrar:fax>
+      <rdeRegistrar:email>jdoe@example.test
+      </rdeRegistrar:email>
+      <rdeRegistrar:url>http://www.example.test
+      </rdeRegistrar:url>
+      <rdeRegistrar:whoisInfo>
+        <rdeRegistrar:name>whois.example.test
+        </rdeRegistrar:name>
+        <rdeRegistrar:url>http://whois.example.test
+        </rdeRegistrar:url>
+      </rdeRegistrar:whoisInfo>
+      <rdeRegistrar:crDate>2005-04-23T11:49:00.0Z</rdeRegistrar:crDate>
+      <rdeRegistrar:upDate>2009-02-17T17:51:00.0Z</rdeRegistrar:upDate>
+    </rdeRegistrar:registrar>
+
+    <!-- IDN Table -->
+    <rdeIDN:idnTableRef id="pt-BR">
+      <rdeIDN:url>
+http://www.iana.org/domains/idn-tables/tables/br_pt-br_1.0.html
+      </rdeIDN:url>
+      <rdeIDN:urlPolicy>
+        http://registro.br/dominio/regras.html
+      </rdeIDN:urlPolicy>
+    </rdeIDN:idnTableRef>
+
+    <!-- NNDN: pinguino.test -->
+    <rdeNNDN:NNDN>
+      <rdeNNDN:aName>xn--exampl-gva.test</rdeNNDN:aName>
+      <rdeNNDN:idnTableId>pt-BR</rdeNNDN:idnTableId>
+      <rdeNNDN:originalName>example1.test</rdeNNDN:originalName>
+      <rdeNNDN:nameState>withheld</rdeNNDN:nameState>
+      <rdeNNDN:crDate>2005-04-23T11:49:00.0Z</rdeNNDN:crDate>
+    </rdeNNDN:NNDN>
+
+    <!-- EppParams -->
+    <rdeEppParams:eppParams>
+      <rdeEppParams:version>1.0</rdeEppParams:version>
+      <rdeEppParams:lang>en</rdeEppParams:lang>
+      <rdeEppParams:objURI>
+        urn:ietf:params:xml:ns:domain-1.0
+      </rdeEppParams:objURI>
+      <rdeEppParams:objURI>
+        urn:ietf:params:xml:ns:contact-1.0
+      </rdeEppParams:objURI>
+      <rdeEppParams:objURI>
+        urn:ietf:params:xml:ns:host-1.0
+      </rdeEppParams:objURI>
+      <rdeEppParams:svcExtension>
+        <epp:extURI>urn:ietf:params:xml:ns:rgp-1.0
+        </epp:extURI>
+        <epp:extURI>urn:ietf:params:xml:ns:secDNS-1.1
+        </epp:extURI>
+      </rdeEppParams:svcExtension>
+      <rdeEppParams:dcp>
+      <epp:access><epp:all/></epp:access>
+        <epp:statement>
+          <epp:purpose>
+            <epp:admin/>
+            <epp:prov/>
+          </epp:purpose>
+          <epp:recipient>
+            <epp:ours/>
+            <epp:public/>
+          </epp:recipient>
+          <epp:retention>
+            <epp:stated/>
+          </epp:retention>
+        </epp:statement>
+      </rdeEppParams:dcp>
+    </rdeEppParams:eppParams>
+  <rdePolicy:policy
+     scope="//rde:deposit/rde:contents/rdeDomain:domain"
+     element="rdeDom:registrant" />
+  </rde:contents>
+</rde:deposit>